binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/epiphany.h"
 106 #include "elf/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/ft32.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/s12z.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nfp.h"
 137 #include "elf/nios2.h"
 138 #include "elf/or1k.h"
 139 #include "elf/pj.h"
 140 #include "elf/ppc.h"
 141 #include "elf/ppc64.h"
 142 #include "elf/pru.h"
 143 #include "elf/riscv.h"
 144 #include "elf/rl78.h"
 145 #include "elf/rx.h"
 146 #include "elf/s390.h"
 147 #include "elf/score.h"
 148 #include "elf/sh.h"
 149 #include "elf/sparc.h"
 150 #include "elf/spu.h"
 151 #include "elf/tic6x.h"
 152 #include "elf/tilegx.h"
 153 #include "elf/tilepro.h"
 154 #include "elf/v850.h"
 155 #include "elf/vax.h"
 156 #include "elf/visium.h"
 157 #include "elf/wasm32.h"
 158 #include "elf/x86-64.h"
 159 #include "elf/xc16x.h"
 160 #include "elf/xgate.h"
 161 #include "elf/xstormy16.h"
 162 #include "elf/xtensa.h"
 163
 164 #include "getopt.h"
 165 #include "libiberty.h"
 166 #include "safe-ctype.h"
 167 #include "filenames.h"
 168
 169 #ifndef offsetof
 170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 171 #endif
 172
 173 typedef struct elf_section_list
 174 {
 175   Elf_Internal_Shdr *        hdr;
 176   struct elf_section_list *  next;
 177 } elf_section_list;
 178
 179 /* Flag bits indicating particular types of dump.  */
 180 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 181 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 182 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 183 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 184 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 185
 186 typedef unsigned char dump_type;
 187
 188 /* A linked list of the section names for which dumps were requested.  */
 189 struct dump_list_entry
 190 {
 191   char *                    name;
 192   dump_type                 type;
 193   struct dump_list_entry *  next;
 194 };
 195
 196 typedef struct filedata
 197 {
 198   const char *         file_name;
 199   FILE *               handle;
 200   bfd_size_type        file_size;
 201   Elf_Internal_Ehdr    file_header;
 202   Elf_Internal_Shdr *  section_headers;
 203   Elf_Internal_Phdr *  program_headers;
 204   char *               string_table;
 205   unsigned long        string_table_length;
 206   /* A dynamic array of flags indicating for which sections a dump of
 207      some kind has been requested.  It is reset on a per-object file
 208      basis and then initialised from the cmdline_dump_sects array,
 209      the results of interpreting the -w switch, and the
 210      dump_sects_byname list.  */
 211   dump_type *          dump_sects;
 212   unsigned int         num_dump_sects;
 213 } Filedata;
 214
 215 char * program_name = "readelf";
 216
 217 static unsigned long archive_file_offset;
 218 static unsigned long archive_file_size;
 219 static unsigned long dynamic_addr;
 220 static bfd_size_type dynamic_size;
 221 static size_t dynamic_nent;
 222 static char * dynamic_strings;
 223 static unsigned long dynamic_strings_length;
 224 static unsigned long num_dynamic_syms;
 225 static Elf_Internal_Sym * dynamic_symbols;
 226 static Elf_Internal_Syminfo * dynamic_syminfo;
 227 static unsigned long dynamic_syminfo_offset;
 228 static unsigned int dynamic_syminfo_nent;
 229 static char program_interpreter[PATH_MAX];
 230 static bfd_vma dynamic_info[DT_ENCODING];
 231 static bfd_vma dynamic_info_DT_GNU_HASH;
 232 static bfd_vma version_info[16];
 233 static Elf_Internal_Dyn *  dynamic_section;
 234 static elf_section_list * symtab_shndx_list;
 235 static bfd_boolean show_name = FALSE;
 236 static bfd_boolean do_dynamic = FALSE;
 237 static bfd_boolean do_syms = FALSE;
 238 static bfd_boolean do_dyn_syms = FALSE;
 239 static bfd_boolean do_reloc = FALSE;
 240 static bfd_boolean do_sections = FALSE;
 241 static bfd_boolean do_section_groups = FALSE;
 242 static bfd_boolean do_section_details = FALSE;
 243 static bfd_boolean do_segments = FALSE;
 244 static bfd_boolean do_unwind = FALSE;
 245 static bfd_boolean do_using_dynamic = FALSE;
 246 static bfd_boolean do_header = FALSE;
 247 static bfd_boolean do_dump = FALSE;
 248 static bfd_boolean do_version = FALSE;
 249 static bfd_boolean do_histogram = FALSE;
 250 static bfd_boolean do_debugging = FALSE;
 251 static bfd_boolean do_arch = FALSE;
 252 static bfd_boolean do_notes = FALSE;
 253 static bfd_boolean do_archive_index = FALSE;
 254 static bfd_boolean is_32bit_elf = FALSE;
 255 static bfd_boolean decompress_dumps = FALSE;
 256
 257 struct group_list
 258 {
 259   struct group_list *  next;
 260   unsigned int         section_index;
 261 };
 262
 263 struct group
 264 {
 265   struct group_list *  root;
 266   unsigned int         group_index;
 267 };
 268
 269 static size_t           group_count;
 270 static struct group *   section_groups;
 271 static struct group **  section_headers_groups;
 272
 273 /* A dynamic array of flags indicating for which sections a dump
 274    has been requested via command line switches.  */
 275 static Filedata         cmdline;
 276
 277 static struct dump_list_entry * dump_sects_byname;
 278
 279 /* How to print a vma value.  */
 280 typedef enum print_mode
 281 {
 282   HEX,
 283   DEC,
 284   DEC_5,
 285   UNSIGNED,
 286   PREFIX_HEX,
 287   FULL_HEX,
 288   LONG_HEX
 289 }
 290 print_mode;
 291
 292 /* Versioned symbol info.  */
 293 enum versioned_symbol_info
 294 {
 295   symbol_undefined,
 296   symbol_hidden,
 297   symbol_public
 298 };
 299
 300 static const char * get_symbol_version_string
 301   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 302    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 303
 304 #define UNKNOWN -1
 305
 306 #define SECTION_NAME(X)                                         \
 307   ((X) == NULL ? _("<none>")                                    \
 308    : filedata->string_table == NULL ? _("<no-strings>")         \
 309    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 310   : filedata->string_table + (X)->sh_name))
 311
 312 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 313
 314 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 315   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 316    : get_64bit_elf_symbols (file, section, sym_count))
 317
 318 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 320    already been called and verified that the string exists.  */
 321 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 322
 323 #define REMOVE_ARCH_BITS(ADDR)                  \
 324   do                                            \
 325     {                                           \
 326       if (filedata->file_header.e_machine == EM_ARM)    \
 327         (ADDR) &= ~1;                           \
 328     }                                           \
 329   while (0)
 330 \f
 331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 332    BFD_FMA_FMT can't be used in translated strings.  */
 333
 334 static const char *
 335 bfd_vmatoa (char *fmtch, bfd_vma value)
 336 {
 337   /* bfd_vmatoa is used more then once in a printf call for output.
 338      Cycle through an array of buffers.  */
 339   static int buf_pos = 0;
 340   static struct bfd_vmatoa_buf
 341   {
 342     char place[64];
 343   } buf[4];
 344   char *ret;
 345   char fmt[32];
 346
 347   ret = buf[buf_pos++].place;
 348   buf_pos %= ARRAY_SIZE (buf);
 349
 350   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 351   snprintf (ret, sizeof (buf[0].place), fmt, value);
 352   return ret;
 353 }
 354
 355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 356    OFFSET + the offset of the current archive member, if we are examining an
 357    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 358    allocate a buffer using malloc and fill that.  In either case return the
 359    pointer to the start of the retrieved data or NULL if something went wrong.
 360    If something does go wrong and REASON is not NULL then emit an error
 361    message using REASON as part of the context.  */
 362
 363 static void *
 364 get_data (void *         var,
 365           Filedata *     filedata,
 366           unsigned long  offset,
 367           bfd_size_type  size,
 368           bfd_size_type  nmemb,
 369           const char *   reason)
 370 {
 371   void * mvar;
 372   bfd_size_type amt = size * nmemb;
 373
 374   if (size == 0 || nmemb == 0)
 375     return NULL;
 376
 377   /* If the size_t type is smaller than the bfd_size_type, eg because
 378      you are building a 32-bit tool on a 64-bit host, then make sure
 379      that when the sizes are cast to (size_t) no information is lost.  */
 380   if (sizeof (size_t) < sizeof (bfd_size_type)
 381       && (   (bfd_size_type) ((size_t) size) != size
 382           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 383     {
 384       if (reason)
 385         error (_("Size truncation prevents reading %s"
 386                  " elements of size %s for %s\n"),
 387                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 388       return NULL;
 389     }
 390
 391   /* Check for size overflow.  */
 392   if (amt < nmemb)
 393     {
 394       if (reason)
 395         error (_("Size overflow prevents reading %s"
 396                  " elements of size %s for %s\n"),
 397                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 398       return NULL;
 399     }
 400
 401   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 402      attempting to allocate memory when the read is bound to fail.  */
 403   if (amt > filedata->file_size
 404       || offset + archive_file_offset + amt > filedata->file_size)
 405     {
 406       if (reason)
 407         error (_("Reading %s bytes extends past end of file for %s\n"),
 408                bfd_vmatoa ("u", amt), reason);
 409       return NULL;
 410     }
 411
 412   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 413     {
 414       if (reason)
 415         error (_("Unable to seek to 0x%lx for %s\n"),
 416                archive_file_offset + offset, reason);
 417       return NULL;
 418     }
 419
 420   mvar = var;
 421   if (mvar == NULL)
 422     {
 423       /* Check for overflow.  */
 424       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 425         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 426         mvar = malloc ((size_t) amt + 1);
 427
 428       if (mvar == NULL)
 429         {
 430           if (reason)
 431             error (_("Out of memory allocating %s bytes for %s\n"),
 432                    bfd_vmatoa ("u", amt), reason);
 433           return NULL;
 434         }
 435
 436       ((char *) mvar)[amt] = '\0';
 437     }
 438
 439   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 440     {
 441       if (reason)
 442         error (_("Unable to read in %s bytes of %s\n"),
 443                bfd_vmatoa ("u", amt), reason);
 444       if (mvar != var)
 445         free (mvar);
 446       return NULL;
 447     }
 448
 449   return mvar;
 450 }
 451
 452 /* Print a VMA value in the MODE specified.
 453    Returns the number of characters displayed.  */
 454
 455 static unsigned int
 456 print_vma (bfd_vma vma, print_mode mode)
 457 {
 458   unsigned int nc = 0;
 459
 460   switch (mode)
 461     {
 462     case FULL_HEX:
 463       nc = printf ("0x");
 464       /* Fall through.  */
 465     case LONG_HEX:
 466 #ifdef BFD64
 467       if (is_32bit_elf)
 468         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 469 #endif
 470       printf_vma (vma);
 471       return nc + 16;
 472
 473     case DEC_5:
 474       if (vma <= 99999)
 475         return printf ("%5" BFD_VMA_FMT "d", vma);
 476       /* Fall through.  */
 477     case PREFIX_HEX:
 478       nc = printf ("0x");
 479       /* Fall through.  */
 480     case HEX:
 481       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 482
 483     case DEC:
 484       return printf ("%" BFD_VMA_FMT "d", vma);
 485
 486     case UNSIGNED:
 487       return printf ("%" BFD_VMA_FMT "u", vma);
 488
 489     default:
 490       /* FIXME: Report unrecognised mode ?  */
 491       return 0;
 492     }
 493 }
 494
 495 /* Display a symbol on stdout.  Handles the display of control characters and
 496    multibye characters (assuming the host environment supports them).
 497
 498    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 499
 500    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 501    padding as necessary.
 502
 503    Returns the number of emitted characters.  */
 504
 505 static unsigned int
 506 print_symbol (signed int width, const char *symbol)
 507 {
 508   bfd_boolean extra_padding = FALSE;
 509   signed int num_printed = 0;
 510 #ifdef HAVE_MBSTATE_T
 511   mbstate_t state;
 512 #endif
 513   unsigned int width_remaining;
 514
 515   if (width < 0)
 516     {
 517       /* Keep the width positive.  This helps the code below.  */
 518       width = - width;
 519       extra_padding = TRUE;
 520     }
 521   else if (width == 0)
 522     return 0;
 523
 524   if (do_wide)
 525     /* Set the remaining width to a very large value.
 526        This simplifies the code below.  */
 527     width_remaining = INT_MAX;
 528   else
 529     width_remaining = width;
 530
 531 #ifdef HAVE_MBSTATE_T
 532   /* Initialise the multibyte conversion state.  */
 533   memset (& state, 0, sizeof (state));
 534 #endif
 535
 536   while (width_remaining)
 537     {
 538       size_t  n;
 539       const char c = *symbol++;
 540
 541       if (c == 0)
 542         break;
 543
 544       /* Do not print control characters directly as they can affect terminal
 545          settings.  Such characters usually appear in the names generated
 546          by the assembler for local labels.  */
 547       if (ISCNTRL (c))
 548         {
 549           if (width_remaining < 2)
 550             break;
 551
 552           printf ("^%c", c + 0x40);
 553           width_remaining -= 2;
 554           num_printed += 2;
 555         }
 556       else if (ISPRINT (c))
 557         {
 558           putchar (c);
 559           width_remaining --;
 560           num_printed ++;
 561         }
 562       else
 563         {
 564 #ifdef HAVE_MBSTATE_T
 565           wchar_t w;
 566 #endif
 567           /* Let printf do the hard work of displaying multibyte characters.  */
 568           printf ("%.1s", symbol - 1);
 569           width_remaining --;
 570           num_printed ++;
 571
 572 #ifdef HAVE_MBSTATE_T
 573           /* Try to find out how many bytes made up the character that was
 574              just printed.  Advance the symbol pointer past the bytes that
 575              were displayed.  */
 576           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 577 #else
 578           n = 1;
 579 #endif
 580           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 581             symbol += (n - 1);
 582         }
 583     }
 584
 585   if (extra_padding && num_printed < width)
 586     {
 587       /* Fill in the remaining spaces.  */
 588       printf ("%-*s", width - num_printed, " ");
 589       num_printed = width;
 590     }
 591
 592   return num_printed;
 593 }
 594
 595 /* Returns a pointer to a static buffer containing a printable version of
 596    the given section's name.  Like print_symbol, except that it does not try
 597    to print multibyte characters, it just interprets them as hex values.  */
 598
 599 static const char *
 600 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 601 {
 602 #define MAX_PRINT_SEC_NAME_LEN 128
 603   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 604   const char * name = SECTION_NAME (sec);
 605   char *       buf = sec_name_buf;
 606   char         c;
 607   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 608
 609   while ((c = * name ++) != 0)
 610     {
 611       if (ISCNTRL (c))
 612         {
 613           if (remaining < 2)
 614             break;
 615
 616           * buf ++ = '^';
 617           * buf ++ = c + 0x40;
 618           remaining -= 2;
 619         }
 620       else if (ISPRINT (c))
 621         {
 622           * buf ++ = c;
 623           remaining -= 1;
 624         }
 625       else
 626         {
 627           static char hex[17] = "0123456789ABCDEF";
 628
 629           if (remaining < 4)
 630             break;
 631           * buf ++ = '<';
 632           * buf ++ = hex[(c & 0xf0) >> 4];
 633           * buf ++ = hex[c & 0x0f];
 634           * buf ++ = '>';
 635           remaining -= 4;
 636         }
 637
 638       if (remaining == 0)
 639         break;
 640     }
 641
 642   * buf = 0;
 643   return sec_name_buf;
 644 }
 645
 646 static const char *
 647 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 648 {
 649   if (ndx >= filedata->file_header.e_shnum)
 650     return _("<corrupt>");
 651
 652   return printable_section_name (filedata, filedata->section_headers + ndx);
 653 }
 654
 655 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 656
 657 static Elf_Internal_Shdr *
 658 find_section (Filedata * filedata, const char * name)
 659 {
 660   unsigned int i;
 661
 662   if (filedata->section_headers == NULL)
 663     return NULL;
 664
 665   for (i = 0; i < filedata->file_header.e_shnum; i++)
 666     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 667       return filedata->section_headers + i;
 668
 669   return NULL;
 670 }
 671
 672 /* Return a pointer to a section containing ADDR, or NULL if no such
 673    section exists.  */
 674
 675 static Elf_Internal_Shdr *
 676 find_section_by_address (Filedata * filedata, bfd_vma addr)
 677 {
 678   unsigned int i;
 679
 680   if (filedata->section_headers == NULL)
 681     return NULL;
 682
 683   for (i = 0; i < filedata->file_header.e_shnum; i++)
 684     {
 685       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 686
 687       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 688         return sec;
 689     }
 690
 691   return NULL;
 692 }
 693
 694 static Elf_Internal_Shdr *
 695 find_section_by_type (Filedata * filedata, unsigned int type)
 696 {
 697   unsigned int i;
 698
 699   if (filedata->section_headers == NULL)
 700     return NULL;
 701
 702   for (i = 0; i < filedata->file_header.e_shnum; i++)
 703     {
 704       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 705
 706       if (sec->sh_type == type)
 707         return sec;
 708     }
 709
 710   return NULL;
 711 }
 712
 713 /* Return a pointer to section NAME, or NULL if no such section exists,
 714    restricted to the list of sections given in SET.  */
 715
 716 static Elf_Internal_Shdr *
 717 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 718 {
 719   unsigned int i;
 720
 721   if (filedata->section_headers == NULL)
 722     return NULL;
 723
 724   if (set != NULL)
 725     {
 726       while ((i = *set++) > 0)
 727         {
 728           /* See PR 21156 for a reproducer.  */
 729           if (i >= filedata->file_header.e_shnum)
 730             continue; /* FIXME: Should we issue an error message ?  */
 731
 732           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 733             return filedata->section_headers + i;
 734         }
 735     }
 736
 737   return find_section (filedata, name);
 738 }
 739
 740 /* Read an unsigned LEB128 encoded value from DATA.
 741    Set *LENGTH_RETURN to the number of bytes read.  */
 742
 743 static inline unsigned long
 744 read_uleb128 (unsigned char * data,
 745               unsigned int * length_return,
 746               const unsigned char * const end)
 747 {
 748   return read_leb128 (data, length_return, FALSE, end);
 749 }
 750
 751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 752    This OS has so many departures from the ELF standard that we test it at
 753    many places.  */
 754
 755 static inline bfd_boolean
 756 is_ia64_vms (Filedata * filedata)
 757 {
 758   return filedata->file_header.e_machine == EM_IA_64
 759     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 760 }
 761
 762 /* Guess the relocation size commonly used by the specific machines.  */
 763
 764 static bfd_boolean
 765 guess_is_rela (unsigned int e_machine)
 766 {
 767   switch (e_machine)
 768     {
 769       /* Targets that use REL relocations.  */
 770     case EM_386:
 771     case EM_IAMCU:
 772     case EM_960:
 773     case EM_ARM:
 774     case EM_D10V:
 775     case EM_CYGNUS_D10V:
 776     case EM_DLX:
 777     case EM_MIPS:
 778     case EM_MIPS_RS3_LE:
 779     case EM_CYGNUS_M32R:
 780     case EM_SCORE:
 781     case EM_XGATE:
 782     case EM_NFP:
 783       return FALSE;
 784
 785       /* Targets that use RELA relocations.  */
 786     case EM_68K:
 787     case EM_860:
 788     case EM_AARCH64:
 789     case EM_ADAPTEVA_EPIPHANY:
 790     case EM_ALPHA:
 791     case EM_ALTERA_NIOS2:
 792     case EM_ARC:
 793     case EM_ARC_COMPACT:
 794     case EM_ARC_COMPACT2:
 795     case EM_AVR:
 796     case EM_AVR_OLD:
 797     case EM_BLACKFIN:
 798     case EM_CR16:
 799     case EM_CRIS:
 800     case EM_CRX:
 801     case EM_CSKY:
 802     case EM_D30V:
 803     case EM_CYGNUS_D30V:
 804     case EM_FR30:
 805     case EM_FT32:
 806     case EM_CYGNUS_FR30:
 807     case EM_CYGNUS_FRV:
 808     case EM_H8S:
 809     case EM_H8_300:
 810     case EM_H8_300H:
 811     case EM_IA_64:
 812     case EM_IP2K:
 813     case EM_IP2K_OLD:
 814     case EM_IQ2000:
 815     case EM_LATTICEMICO32:
 816     case EM_M32C_OLD:
 817     case EM_M32C:
 818     case EM_M32R:
 819     case EM_MCORE:
 820     case EM_CYGNUS_MEP:
 821     case EM_METAG:
 822     case EM_MMIX:
 823     case EM_MN10200:
 824     case EM_CYGNUS_MN10200:
 825     case EM_MN10300:
 826     case EM_CYGNUS_MN10300:
 827     case EM_MOXIE:
 828     case EM_MSP430:
 829     case EM_MSP430_OLD:
 830     case EM_MT:
 831     case EM_NDS32:
 832     case EM_NIOS32:
 833     case EM_OR1K:
 834     case EM_PPC64:
 835     case EM_PPC:
 836     case EM_TI_PRU:
 837     case EM_RISCV:
 838     case EM_RL78:
 839     case EM_RX:
 840     case EM_S390:
 841     case EM_S390_OLD:
 842     case EM_SH:
 843     case EM_SPARC:
 844     case EM_SPARC32PLUS:
 845     case EM_SPARCV9:
 846     case EM_SPU:
 847     case EM_TI_C6000:
 848     case EM_TILEGX:
 849     case EM_TILEPRO:
 850     case EM_V800:
 851     case EM_V850:
 852     case EM_CYGNUS_V850:
 853     case EM_VAX:
 854     case EM_VISIUM:
 855     case EM_X86_64:
 856     case EM_L1OM:
 857     case EM_K1OM:
 858     case EM_XSTORMY16:
 859     case EM_XTENSA:
 860     case EM_XTENSA_OLD:
 861     case EM_MICROBLAZE:
 862     case EM_MICROBLAZE_OLD:
 863     case EM_WEBASSEMBLY:
 864       return TRUE;
 865
 866     case EM_68HC05:
 867     case EM_68HC08:
 868     case EM_68HC11:
 869     case EM_68HC16:
 870     case EM_FX66:
 871     case EM_ME16:
 872     case EM_MMA:
 873     case EM_NCPU:
 874     case EM_NDR1:
 875     case EM_PCP:
 876     case EM_ST100:
 877     case EM_ST19:
 878     case EM_ST7:
 879     case EM_ST9PLUS:
 880     case EM_STARCORE:
 881     case EM_SVX:
 882     case EM_TINYJ:
 883     default:
 884       warn (_("Don't know about relocations on this machine architecture\n"));
 885       return FALSE;
 886     }
 887 }
 888
 889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 890    Returns TRUE upon success, FALSE otherwise.  If successful then a
 891    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 892    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 893    responsibility to free the allocated buffer.  */
 894
 895 static bfd_boolean
 896 slurp_rela_relocs (Filedata *            filedata,
 897                    unsigned long         rel_offset,
 898                    unsigned long         rel_size,
 899                    Elf_Internal_Rela **  relasp,
 900                    unsigned long *       nrelasp)
 901 {
 902   Elf_Internal_Rela * relas;
 903   size_t nrelas;
 904   unsigned int i;
 905
 906   if (is_32bit_elf)
 907     {
 908       Elf32_External_Rela * erelas;
 909
 910       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 911                                                  rel_size, _("32-bit relocation data"));
 912       if (!erelas)
 913         return FALSE;
 914
 915       nrelas = rel_size / sizeof (Elf32_External_Rela);
 916
 917       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 918                                              sizeof (Elf_Internal_Rela));
 919
 920       if (relas == NULL)
 921         {
 922           free (erelas);
 923           error (_("out of memory parsing relocs\n"));
 924           return FALSE;
 925         }
 926
 927       for (i = 0; i < nrelas; i++)
 928         {
 929           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 930           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 931           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 932         }
 933
 934       free (erelas);
 935     }
 936   else
 937     {
 938       Elf64_External_Rela * erelas;
 939
 940       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 941                                                  rel_size, _("64-bit relocation data"));
 942       if (!erelas)
 943         return FALSE;
 944
 945       nrelas = rel_size / sizeof (Elf64_External_Rela);
 946
 947       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 948                                              sizeof (Elf_Internal_Rela));
 949
 950       if (relas == NULL)
 951         {
 952           free (erelas);
 953           error (_("out of memory parsing relocs\n"));
 954           return FALSE;
 955         }
 956
 957       for (i = 0; i < nrelas; i++)
 958         {
 959           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 960           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 961           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 962
 963           /* The #ifdef BFD64 below is to prevent a compile time
 964              warning.  We know that if we do not have a 64 bit data
 965              type that we will never execute this code anyway.  */
 966 #ifdef BFD64
 967           if (filedata->file_header.e_machine == EM_MIPS
 968               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 969             {
 970               /* In little-endian objects, r_info isn't really a
 971                  64-bit little-endian value: it has a 32-bit
 972                  little-endian symbol index followed by four
 973                  individual byte fields.  Reorder INFO
 974                  accordingly.  */
 975               bfd_vma inf = relas[i].r_info;
 976               inf = (((inf & 0xffffffff) << 32)
 977                       | ((inf >> 56) & 0xff)
 978                       | ((inf >> 40) & 0xff00)
 979                       | ((inf >> 24) & 0xff0000)
 980                       | ((inf >> 8) & 0xff000000));
 981               relas[i].r_info = inf;
 982             }
 983 #endif /* BFD64 */
 984         }
 985
 986       free (erelas);
 987     }
 988
 989   *relasp = relas;
 990   *nrelasp = nrelas;
 991   return TRUE;
 992 }
 993
 994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 995    Returns TRUE upon success, FALSE otherwise.  If successful then a
 996    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 997    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 998    responsibility to free the allocated buffer.  */
 999
1000 static bfd_boolean
1001 slurp_rel_relocs (Filedata *            filedata,
1002                   unsigned long         rel_offset,
1003                   unsigned long         rel_size,
1004                   Elf_Internal_Rela **  relsp,
1005                   unsigned long *       nrelsp)
1006 {
1007   Elf_Internal_Rela * rels;
1008   size_t nrels;
1009   unsigned int i;
1010
1011   if (is_32bit_elf)
1012     {
1013       Elf32_External_Rel * erels;
1014
1015       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016                                                rel_size, _("32-bit relocation data"));
1017       if (!erels)
1018         return FALSE;
1019
1020       nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024       if (rels == NULL)
1025         {
1026           free (erels);
1027           error (_("out of memory parsing relocs\n"));
1028           return FALSE;
1029         }
1030
1031       for (i = 0; i < nrels; i++)
1032         {
1033           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1035           rels[i].r_addend = 0;
1036         }
1037
1038       free (erels);
1039     }
1040   else
1041     {
1042       Elf64_External_Rel * erels;
1043
1044       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045                                                rel_size, _("64-bit relocation data"));
1046       if (!erels)
1047         return FALSE;
1048
1049       nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053       if (rels == NULL)
1054         {
1055           free (erels);
1056           error (_("out of memory parsing relocs\n"));
1057           return FALSE;
1058         }
1059
1060       for (i = 0; i < nrels; i++)
1061         {
1062           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1064           rels[i].r_addend = 0;
1065
1066           /* The #ifdef BFD64 below is to prevent a compile time
1067              warning.  We know that if we do not have a 64 bit data
1068              type that we will never execute this code anyway.  */
1069 #ifdef BFD64
1070           if (filedata->file_header.e_machine == EM_MIPS
1071               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072             {
1073               /* In little-endian objects, r_info isn't really a
1074                  64-bit little-endian value: it has a 32-bit
1075                  little-endian symbol index followed by four
1076                  individual byte fields.  Reorder INFO
1077                  accordingly.  */
1078               bfd_vma inf = rels[i].r_info;
1079               inf = (((inf & 0xffffffff) << 32)
1080                      | ((inf >> 56) & 0xff)
1081                      | ((inf >> 40) & 0xff00)
1082                      | ((inf >> 24) & 0xff0000)
1083                      | ((inf >> 8) & 0xff000000));
1084               rels[i].r_info = inf;
1085             }
1086 #endif /* BFD64 */
1087         }
1088
1089       free (erels);
1090     }
1091
1092   *relsp = rels;
1093   *nrelsp = nrels;
1094   return TRUE;
1095 }
1096
1097 /* Returns the reloc type extracted from the reloc info field.  */
1098
1099 static unsigned int
1100 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101 {
1102   if (is_32bit_elf)
1103     return ELF32_R_TYPE (reloc_info);
1104
1105   switch (filedata->file_header.e_machine)
1106     {
1107     case EM_MIPS:
1108       /* Note: We assume that reloc_info has already been adjusted for us.  */
1109       return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111     case EM_SPARCV9:
1112       return ELF64_R_TYPE_ID (reloc_info);
1113
1114     default:
1115       return ELF64_R_TYPE (reloc_info);
1116     }
1117 }
1118
1119 /* Return the symbol index extracted from the reloc info field.  */
1120
1121 static bfd_vma
1122 get_reloc_symindex (bfd_vma reloc_info)
1123 {
1124   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125 }
1126
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata * filedata)
1129 {
1130   return
1131     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1132     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1133     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134         /* TI compiler uses ELFOSABI_NONE.  */
1135         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136 }
1137
1138 /* Display the contents of the relocation data found at the specified
1139    offset.  */
1140
1141 static bfd_boolean
1142 dump_relocations (Filedata *          filedata,
1143                   unsigned long       rel_offset,
1144                   unsigned long       rel_size,
1145                   Elf_Internal_Sym *  symtab,
1146                   unsigned long       nsyms,
1147                   char *              strtab,
1148                   unsigned long       strtablen,
1149                   int                 is_rela,
1150                   bfd_boolean         is_dynsym)
1151 {
1152   unsigned long i;
1153   Elf_Internal_Rela * rels;
1154   bfd_boolean res = TRUE;
1155
1156   if (is_rela == UNKNOWN)
1157     is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159   if (is_rela)
1160     {
1161       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162         return FALSE;
1163     }
1164   else
1165     {
1166       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167         return FALSE;
1168     }
1169
1170   if (is_32bit_elf)
1171     {
1172       if (is_rela)
1173         {
1174           if (do_wide)
1175             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1176           else
1177             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1178         }
1179       else
1180         {
1181           if (do_wide)
1182             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1183           else
1184             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1185         }
1186     }
1187   else
1188     {
1189       if (is_rela)
1190         {
1191           if (do_wide)
1192             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1193           else
1194             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1195         }
1196       else
1197         {
1198           if (do_wide)
1199             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1200           else
1201             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1202         }
1203     }
1204
1205   for (i = 0; i < rel_size; i++)
1206     {
1207       const char * rtype;
1208       bfd_vma offset;
1209       bfd_vma inf;
1210       bfd_vma symtab_index;
1211       bfd_vma type;
1212
1213       offset = rels[i].r_offset;
1214       inf    = rels[i].r_info;
1215
1216       type = get_reloc_type (filedata, inf);
1217       symtab_index = get_reloc_symindex  (inf);
1218
1219       if (is_32bit_elf)
1220         {
1221           printf ("%8.8lx  %8.8lx ",
1222                   (unsigned long) offset & 0xffffffff,
1223                   (unsigned long) inf & 0xffffffff);
1224         }
1225       else
1226         {
1227 #if BFD_HOST_64BIT_LONG
1228           printf (do_wide
1229                   ? "%16.16lx  %16.16lx "
1230                   : "%12.12lx  %12.12lx ",
1231                   offset, inf);
1232 #elif BFD_HOST_64BIT_LONG_LONG
1233 #ifndef __MSVCRT__
1234           printf (do_wide
1235                   ? "%16.16llx  %16.16llx "
1236                   : "%12.12llx  %12.12llx ",
1237                   offset, inf);
1238 #else
1239           printf (do_wide
1240                   ? "%16.16I64x  %16.16I64x "
1241                   : "%12.12I64x  %12.12I64x ",
1242                   offset, inf);
1243 #endif
1244 #else
1245           printf (do_wide
1246                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1247                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1248                   _bfd_int64_high (offset),
1249                   _bfd_int64_low (offset),
1250                   _bfd_int64_high (inf),
1251                   _bfd_int64_low (inf));
1252 #endif
1253         }
1254
1255       switch (filedata->file_header.e_machine)
1256         {
1257         default:
1258           rtype = NULL;
1259           break;
1260
1261         case EM_AARCH64:
1262           rtype = elf_aarch64_reloc_type (type);
1263           break;
1264
1265         case EM_M32R:
1266         case EM_CYGNUS_M32R:
1267           rtype = elf_m32r_reloc_type (type);
1268           break;
1269
1270         case EM_386:
1271         case EM_IAMCU:
1272           rtype = elf_i386_reloc_type (type);
1273           break;
1274
1275         case EM_68HC11:
1276         case EM_68HC12:
1277           rtype = elf_m68hc11_reloc_type (type);
1278           break;
1279
1280         case EM_S12Z:
1281           rtype = elf_s12z_reloc_type (type);
1282           break;
1283
1284         case EM_68K:
1285           rtype = elf_m68k_reloc_type (type);
1286           break;
1287
1288         case EM_960:
1289           rtype = elf_i960_reloc_type (type);
1290           break;
1291
1292         case EM_AVR:
1293         case EM_AVR_OLD:
1294           rtype = elf_avr_reloc_type (type);
1295           break;
1296
1297         case EM_OLD_SPARCV9:
1298         case EM_SPARC32PLUS:
1299         case EM_SPARCV9:
1300         case EM_SPARC:
1301           rtype = elf_sparc_reloc_type (type);
1302           break;
1303
1304         case EM_SPU:
1305           rtype = elf_spu_reloc_type (type);
1306           break;
1307
1308         case EM_V800:
1309           rtype = v800_reloc_type (type);
1310           break;
1311         case EM_V850:
1312         case EM_CYGNUS_V850:
1313           rtype = v850_reloc_type (type);
1314           break;
1315
1316         case EM_D10V:
1317         case EM_CYGNUS_D10V:
1318           rtype = elf_d10v_reloc_type (type);
1319           break;
1320
1321         case EM_D30V:
1322         case EM_CYGNUS_D30V:
1323           rtype = elf_d30v_reloc_type (type);
1324           break;
1325
1326         case EM_DLX:
1327           rtype = elf_dlx_reloc_type (type);
1328           break;
1329
1330         case EM_SH:
1331           rtype = elf_sh_reloc_type (type);
1332           break;
1333
1334         case EM_MN10300:
1335         case EM_CYGNUS_MN10300:
1336           rtype = elf_mn10300_reloc_type (type);
1337           break;
1338
1339         case EM_MN10200:
1340         case EM_CYGNUS_MN10200:
1341           rtype = elf_mn10200_reloc_type (type);
1342           break;
1343
1344         case EM_FR30:
1345         case EM_CYGNUS_FR30:
1346           rtype = elf_fr30_reloc_type (type);
1347           break;
1348
1349         case EM_CYGNUS_FRV:
1350           rtype = elf_frv_reloc_type (type);
1351           break;
1352
1353         case EM_CSKY:
1354           rtype = elf_csky_reloc_type (type);
1355           break;
1356
1357         case EM_FT32:
1358           rtype = elf_ft32_reloc_type (type);
1359           break;
1360
1361         case EM_MCORE:
1362           rtype = elf_mcore_reloc_type (type);
1363           break;
1364
1365         case EM_MMIX:
1366           rtype = elf_mmix_reloc_type (type);
1367           break;
1368
1369         case EM_MOXIE:
1370           rtype = elf_moxie_reloc_type (type);
1371           break;
1372
1373         case EM_MSP430:
1374           if (uses_msp430x_relocs (filedata))
1375             {
1376               rtype = elf_msp430x_reloc_type (type);
1377               break;
1378             }
1379           /* Fall through.  */
1380         case EM_MSP430_OLD:
1381           rtype = elf_msp430_reloc_type (type);
1382           break;
1383
1384         case EM_NDS32:
1385           rtype = elf_nds32_reloc_type (type);
1386           break;
1387
1388         case EM_PPC:
1389           rtype = elf_ppc_reloc_type (type);
1390           break;
1391
1392         case EM_PPC64:
1393           rtype = elf_ppc64_reloc_type (type);
1394           break;
1395
1396         case EM_MIPS:
1397         case EM_MIPS_RS3_LE:
1398           rtype = elf_mips_reloc_type (type);
1399           break;
1400
1401         case EM_RISCV:
1402           rtype = elf_riscv_reloc_type (type);
1403           break;
1404
1405         case EM_ALPHA:
1406           rtype = elf_alpha_reloc_type (type);
1407           break;
1408
1409         case EM_ARM:
1410           rtype = elf_arm_reloc_type (type);
1411           break;
1412
1413         case EM_ARC:
1414         case EM_ARC_COMPACT:
1415         case EM_ARC_COMPACT2:
1416           rtype = elf_arc_reloc_type (type);
1417           break;
1418
1419         case EM_PARISC:
1420           rtype = elf_hppa_reloc_type (type);
1421           break;
1422
1423         case EM_H8_300:
1424         case EM_H8_300H:
1425         case EM_H8S:
1426           rtype = elf_h8_reloc_type (type);
1427           break;
1428
1429         case EM_OR1K:
1430           rtype = elf_or1k_reloc_type (type);
1431           break;
1432
1433         case EM_PJ:
1434         case EM_PJ_OLD:
1435           rtype = elf_pj_reloc_type (type);
1436           break;
1437         case EM_IA_64:
1438           rtype = elf_ia64_reloc_type (type);
1439           break;
1440
1441         case EM_CRIS:
1442           rtype = elf_cris_reloc_type (type);
1443           break;
1444
1445         case EM_860:
1446           rtype = elf_i860_reloc_type (type);
1447           break;
1448
1449         case EM_X86_64:
1450         case EM_L1OM:
1451         case EM_K1OM:
1452           rtype = elf_x86_64_reloc_type (type);
1453           break;
1454
1455         case EM_S370:
1456           rtype = i370_reloc_type (type);
1457           break;
1458
1459         case EM_S390_OLD:
1460         case EM_S390:
1461           rtype = elf_s390_reloc_type (type);
1462           break;
1463
1464         case EM_SCORE:
1465           rtype = elf_score_reloc_type (type);
1466           break;
1467
1468         case EM_XSTORMY16:
1469           rtype = elf_xstormy16_reloc_type (type);
1470           break;
1471
1472         case EM_CRX:
1473           rtype = elf_crx_reloc_type (type);
1474           break;
1475
1476         case EM_VAX:
1477           rtype = elf_vax_reloc_type (type);
1478           break;
1479
1480         case EM_VISIUM:
1481           rtype = elf_visium_reloc_type (type);
1482           break;
1483
1484         case EM_ADAPTEVA_EPIPHANY:
1485           rtype = elf_epiphany_reloc_type (type);
1486           break;
1487
1488         case EM_IP2K:
1489         case EM_IP2K_OLD:
1490           rtype = elf_ip2k_reloc_type (type);
1491           break;
1492
1493         case EM_IQ2000:
1494           rtype = elf_iq2000_reloc_type (type);
1495           break;
1496
1497         case EM_XTENSA_OLD:
1498         case EM_XTENSA:
1499           rtype = elf_xtensa_reloc_type (type);
1500           break;
1501
1502         case EM_LATTICEMICO32:
1503           rtype = elf_lm32_reloc_type (type);
1504           break;
1505
1506         case EM_M32C_OLD:
1507         case EM_M32C:
1508           rtype = elf_m32c_reloc_type (type);
1509           break;
1510
1511         case EM_MT:
1512           rtype = elf_mt_reloc_type (type);
1513           break;
1514
1515         case EM_BLACKFIN:
1516           rtype = elf_bfin_reloc_type (type);
1517           break;
1518
1519         case EM_CYGNUS_MEP:
1520           rtype = elf_mep_reloc_type (type);
1521           break;
1522
1523         case EM_CR16:
1524           rtype = elf_cr16_reloc_type (type);
1525           break;
1526
1527         case EM_MICROBLAZE:
1528         case EM_MICROBLAZE_OLD:
1529           rtype = elf_microblaze_reloc_type (type);
1530           break;
1531
1532         case EM_RL78:
1533           rtype = elf_rl78_reloc_type (type);
1534           break;
1535
1536         case EM_RX:
1537           rtype = elf_rx_reloc_type (type);
1538           break;
1539
1540         case EM_METAG:
1541           rtype = elf_metag_reloc_type (type);
1542           break;
1543
1544         case EM_XC16X:
1545         case EM_C166:
1546           rtype = elf_xc16x_reloc_type (type);
1547           break;
1548
1549         case EM_TI_C6000:
1550           rtype = elf_tic6x_reloc_type (type);
1551           break;
1552
1553         case EM_TILEGX:
1554           rtype = elf_tilegx_reloc_type (type);
1555           break;
1556
1557         case EM_TILEPRO:
1558           rtype = elf_tilepro_reloc_type (type);
1559           break;
1560
1561         case EM_WEBASSEMBLY:
1562           rtype = elf_wasm32_reloc_type (type);
1563           break;
1564
1565         case EM_XGATE:
1566           rtype = elf_xgate_reloc_type (type);
1567           break;
1568
1569         case EM_ALTERA_NIOS2:
1570           rtype = elf_nios2_reloc_type (type);
1571           break;
1572
1573         case EM_TI_PRU:
1574           rtype = elf_pru_reloc_type (type);
1575           break;
1576
1577         case EM_NFP:
1578           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579             rtype = elf_nfp3200_reloc_type (type);
1580           else
1581             rtype = elf_nfp_reloc_type (type);
1582           break;
1583         }
1584
1585       if (rtype == NULL)
1586         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587       else
1588         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590       if (filedata->file_header.e_machine == EM_ALPHA
1591           && rtype != NULL
1592           && streq (rtype, "R_ALPHA_LITUSE")
1593           && is_rela)
1594         {
1595           switch (rels[i].r_addend)
1596             {
1597             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1598             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1599             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1601             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1602             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604             default: rtype = NULL;
1605             }
1606
1607           if (rtype)
1608             printf (" (%s)", rtype);
1609           else
1610             {
1611               putchar (' ');
1612               printf (_("<unknown addend: %lx>"),
1613                       (unsigned long) rels[i].r_addend);
1614               res = FALSE;
1615             }
1616         }
1617       else if (symtab_index)
1618         {
1619           if (symtab == NULL || symtab_index >= nsyms)
1620             {
1621               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622               res = FALSE;
1623             }
1624           else
1625             {
1626               Elf_Internal_Sym * psym;
1627               const char * version_string;
1628               enum versioned_symbol_info sym_info;
1629               unsigned short vna_other;
1630
1631               psym = symtab + symtab_index;
1632
1633               version_string
1634                 = get_symbol_version_string (filedata, is_dynsym,
1635                                              strtab, strtablen,
1636                                              symtab_index,
1637                                              psym,
1638                                              &sym_info,
1639                                              &vna_other);
1640
1641               printf (" ");
1642
1643               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644                 {
1645                   const char * name;
1646                   unsigned int len;
1647                   unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649                   /* Relocations against GNU_IFUNC symbols do not use the value
1650                      of the symbol as the address to relocate against.  Instead
1651                      they invoke the function named by the symbol and use its
1652                      result as the address for relocation.
1653
1654                      To indicate this to the user, do not display the value of
1655                      the symbol in the "Symbols's Value" field.  Instead show
1656                      its name followed by () as a hint that the symbol is
1657                      invoked.  */
1658
1659                   if (strtab == NULL
1660                       || psym->st_name == 0
1661                       || psym->st_name >= strtablen)
1662                     name = "??";
1663                   else
1664                     name = strtab + psym->st_name;
1665
1666                   len = print_symbol (width, name);
1667                   if (version_string)
1668                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669                             version_string);
1670                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671                 }
1672               else
1673                 {
1674                   print_vma (psym->st_value, LONG_HEX);
1675
1676                   printf (is_32bit_elf ? "   " : " ");
1677                 }
1678
1679               if (psym->st_name == 0)
1680                 {
1681                   const char * sec_name = "<null>";
1682                   char name_buf[40];
1683
1684                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685                     {
1686                       if (psym->st_shndx < filedata->file_header.e_shnum)
1687                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688                       else if (psym->st_shndx == SHN_ABS)
1689                         sec_name = "ABS";
1690                       else if (psym->st_shndx == SHN_COMMON)
1691                         sec_name = "COMMON";
1692                       else if ((filedata->file_header.e_machine == EM_MIPS
1693                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694                                || (filedata->file_header.e_machine == EM_TI_C6000
1695                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696                         sec_name = "SCOMMON";
1697                       else if (filedata->file_header.e_machine == EM_MIPS
1698                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699                         sec_name = "SUNDEF";
1700                       else if ((filedata->file_header.e_machine == EM_X86_64
1701                                 || filedata->file_header.e_machine == EM_L1OM
1702                                 || filedata->file_header.e_machine == EM_K1OM)
1703                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1704                         sec_name = "LARGE_COMMON";
1705                       else if (filedata->file_header.e_machine == EM_IA_64
1706                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708                         sec_name = "ANSI_COM";
1709                       else if (is_ia64_vms (filedata)
1710                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711                         sec_name = "VMS_SYMVEC";
1712                       else
1713                         {
1714                           sprintf (name_buf, "<section 0x%x>",
1715                                    (unsigned int) psym->st_shndx);
1716                           sec_name = name_buf;
1717                         }
1718                     }
1719                   print_symbol (22, sec_name);
1720                 }
1721               else if (strtab == NULL)
1722                 printf (_("<string table index: %3ld>"), psym->st_name);
1723               else if (psym->st_name >= strtablen)
1724                 {
1725                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726                   res = FALSE;
1727                 }
1728               else
1729                 {
1730                   print_symbol (22, strtab + psym->st_name);
1731                   if (version_string)
1732                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733                             version_string);
1734                 }
1735
1736               if (is_rela)
1737                 {
1738                   bfd_vma off = rels[i].r_addend;
1739
1740                   if ((bfd_signed_vma) off < 0)
1741                     printf (" - %" BFD_VMA_FMT "x", - off);
1742                   else
1743                     printf (" + %" BFD_VMA_FMT "x", off);
1744                 }
1745             }
1746         }
1747       else if (is_rela)
1748         {
1749           bfd_vma off = rels[i].r_addend;
1750
1751           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752           if ((bfd_signed_vma) off < 0)
1753             printf ("-%" BFD_VMA_FMT "x", - off);
1754           else
1755             printf ("%" BFD_VMA_FMT "x", off);
1756         }
1757
1758       if (filedata->file_header.e_machine == EM_SPARCV9
1759           && rtype != NULL
1760           && streq (rtype, "R_SPARC_OLO10"))
1761         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763       putchar ('\n');
1764
1765 #ifdef BFD64
1766       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767         {
1768           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770           const char * rtype2 = elf_mips_reloc_type (type2);
1771           const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773           printf ("                    Type2: ");
1774
1775           if (rtype2 == NULL)
1776             printf (_("unrecognized: %-7lx"),
1777                     (unsigned long) type2 & 0xffffffff);
1778           else
1779             printf ("%-17.17s", rtype2);
1780
1781           printf ("\n                    Type3: ");
1782
1783           if (rtype3 == NULL)
1784             printf (_("unrecognized: %-7lx"),
1785                     (unsigned long) type3 & 0xffffffff);
1786           else
1787             printf ("%-17.17s", rtype3);
1788
1789           putchar ('\n');
1790         }
1791 #endif /* BFD64 */
1792     }
1793
1794   free (rels);
1795
1796   return res;
1797 }
1798
1799 static const char *
1800 get_mips_dynamic_type (unsigned long type)
1801 {
1802   switch (type)
1803     {
1804     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810     case DT_MIPS_MSYM: return "MIPS_MSYM";
1811     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_sparc64_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861     default:
1862       return NULL;
1863     }
1864 }
1865
1866 static const char *
1867 get_ppc_dynamic_type (unsigned long type)
1868 {
1869   switch (type)
1870     {
1871     case DT_PPC_GOT:    return "PPC_GOT";
1872     case DT_PPC_OPT:    return "PPC_OPT";
1873     default:
1874       return NULL;
1875     }
1876 }
1877
1878 static const char *
1879 get_ppc64_dynamic_type (unsigned long type)
1880 {
1881   switch (type)
1882     {
1883     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1884     case DT_PPC64_OPD:    return "PPC64_OPD";
1885     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1886     case DT_PPC64_OPT:    return "PPC64_OPT";
1887     default:
1888       return NULL;
1889     }
1890 }
1891
1892 static const char *
1893 get_parisc_dynamic_type (unsigned long type)
1894 {
1895   switch (type)
1896     {
1897     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1898     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1899     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1900     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1901     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1902     case DT_HP_PREINIT:         return "HP_PREINIT";
1903     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1904     case DT_HP_NEEDED:          return "HP_NEEDED";
1905     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1906     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1907     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1908     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1909     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1910     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1911     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1912     case DT_HP_FILTERED:        return "HP_FILTERED";
1913     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1914     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1916     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1917     case DT_PLT:                return "PLT";
1918     case DT_PLT_SIZE:           return "PLT_SIZE";
1919     case DT_DLT:                return "DLT";
1920     case DT_DLT_SIZE:           return "DLT_SIZE";
1921     default:
1922       return NULL;
1923     }
1924 }
1925
1926 static const char *
1927 get_ia64_dynamic_type (unsigned long type)
1928 {
1929   switch (type)
1930     {
1931     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1932     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1933     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1934     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1935     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1937     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1938     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1939     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1940     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1941     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1942     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1943     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1944     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1945     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1946     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1947     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1948     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1949     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1950     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1951     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1952     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1953     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1954     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1955     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1956     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1957     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1958     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1959     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1960     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1961     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1962     default:
1963       return NULL;
1964     }
1965 }
1966
1967 static const char *
1968 get_solaris_section_type (unsigned long type)
1969 {
1970   switch (type)
1971     {
1972     case 0x6fffffee: return "SUNW_ancillary";
1973     case 0x6fffffef: return "SUNW_capchain";
1974     case 0x6ffffff0: return "SUNW_capinfo";
1975     case 0x6ffffff1: return "SUNW_symsort";
1976     case 0x6ffffff2: return "SUNW_tlssort";
1977     case 0x6ffffff3: return "SUNW_LDYNSYM";
1978     case 0x6ffffff4: return "SUNW_dof";
1979     case 0x6ffffff5: return "SUNW_cap";
1980     case 0x6ffffff6: return "SUNW_SIGNATURE";
1981     case 0x6ffffff7: return "SUNW_ANNOTATE";
1982     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983     case 0x6ffffff9: return "SUNW_DEBUG";
1984     case 0x6ffffffa: return "SUNW_move";
1985     case 0x6ffffffb: return "SUNW_COMDAT";
1986     case 0x6ffffffc: return "SUNW_syminfo";
1987     case 0x6ffffffd: return "SUNW_verdef";
1988     case 0x6ffffffe: return "SUNW_verneed";
1989     case 0x6fffffff: return "SUNW_versym";
1990     case 0x70000000: return "SPARC_GOTDATA";
1991     default: return NULL;
1992     }
1993 }
1994
1995 static const char *
1996 get_alpha_dynamic_type (unsigned long type)
1997 {
1998   switch (type)
1999     {
2000     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001     default: return NULL;
2002     }
2003 }
2004
2005 static const char *
2006 get_score_dynamic_type (unsigned long type)
2007 {
2008   switch (type)
2009     {
2010     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2012     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2013     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2014     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2015     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2016     default:                    return NULL;
2017     }
2018 }
2019
2020 static const char *
2021 get_tic6x_dynamic_type (unsigned long type)
2022 {
2023   switch (type)
2024     {
2025     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2028     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2029     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2030     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2031     default:                   return NULL;
2032     }
2033 }
2034
2035 static const char *
2036 get_nios2_dynamic_type (unsigned long type)
2037 {
2038   switch (type)
2039     {
2040     case DT_NIOS2_GP: return "NIOS2_GP";
2041     default:          return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_solaris_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case 0x6000000d: return "SUNW_AUXILIARY";
2051     case 0x6000000e: return "SUNW_RTLDINF";
2052     case 0x6000000f: return "SUNW_FILTER";
2053     case 0x60000010: return "SUNW_CAP";
2054     case 0x60000011: return "SUNW_SYMTAB";
2055     case 0x60000012: return "SUNW_SYMSZ";
2056     case 0x60000013: return "SUNW_SORTENT";
2057     case 0x60000014: return "SUNW_SYMSORT";
2058     case 0x60000015: return "SUNW_SYMSORTSZ";
2059     case 0x60000016: return "SUNW_TLSSORT";
2060     case 0x60000017: return "SUNW_TLSSORTSZ";
2061     case 0x60000018: return "SUNW_CAPINFO";
2062     case 0x60000019: return "SUNW_STRPAD";
2063     case 0x6000001a: return "SUNW_CAPCHAIN";
2064     case 0x6000001b: return "SUNW_LDMACH";
2065     case 0x6000001d: return "SUNW_CAPCHAINENT";
2066     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067     case 0x60000021: return "SUNW_PARENT";
2068     case 0x60000023: return "SUNW_ASLR";
2069     case 0x60000025: return "SUNW_RELAX";
2070     case 0x60000029: return "SUNW_NXHEAP";
2071     case 0x6000002b: return "SUNW_NXSTACK";
2072
2073     case 0x70000001: return "SPARC_REGISTER";
2074     case 0x7ffffffd: return "AUXILIARY";
2075     case 0x7ffffffe: return "USED";
2076     case 0x7fffffff: return "FILTER";
2077
2078     default: return NULL;
2079     }
2080 }
2081
2082 static const char *
2083 get_dynamic_type (Filedata * filedata, unsigned long type)
2084 {
2085   static char buff[64];
2086
2087   switch (type)
2088     {
2089     case DT_NULL:       return "NULL";
2090     case DT_NEEDED:     return "NEEDED";
2091     case DT_PLTRELSZ:   return "PLTRELSZ";
2092     case DT_PLTGOT:     return "PLTGOT";
2093     case DT_HASH:       return "HASH";
2094     case DT_STRTAB:     return "STRTAB";
2095     case DT_SYMTAB:     return "SYMTAB";
2096     case DT_RELA:       return "RELA";
2097     case DT_RELASZ:     return "RELASZ";
2098     case DT_RELAENT:    return "RELAENT";
2099     case DT_STRSZ:      return "STRSZ";
2100     case DT_SYMENT:     return "SYMENT";
2101     case DT_INIT:       return "INIT";
2102     case DT_FINI:       return "FINI";
2103     case DT_SONAME:     return "SONAME";
2104     case DT_RPATH:      return "RPATH";
2105     case DT_SYMBOLIC:   return "SYMBOLIC";
2106     case DT_REL:        return "REL";
2107     case DT_RELSZ:      return "RELSZ";
2108     case DT_RELENT:     return "RELENT";
2109     case DT_PLTREL:     return "PLTREL";
2110     case DT_DEBUG:      return "DEBUG";
2111     case DT_TEXTREL:    return "TEXTREL";
2112     case DT_JMPREL:     return "JMPREL";
2113     case DT_BIND_NOW:   return "BIND_NOW";
2114     case DT_INIT_ARRAY: return "INIT_ARRAY";
2115     case DT_FINI_ARRAY: return "FINI_ARRAY";
2116     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118     case DT_RUNPATH:    return "RUNPATH";
2119     case DT_FLAGS:      return "FLAGS";
2120
2121     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125     case DT_CHECKSUM:   return "CHECKSUM";
2126     case DT_PLTPADSZ:   return "PLTPADSZ";
2127     case DT_MOVEENT:    return "MOVEENT";
2128     case DT_MOVESZ:     return "MOVESZ";
2129     case DT_FEATURE:    return "FEATURE";
2130     case DT_POSFLAG_1:  return "POSFLAG_1";
2131     case DT_SYMINSZ:    return "SYMINSZ";
2132     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2133
2134     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2135     case DT_CONFIG:     return "CONFIG";
2136     case DT_DEPAUDIT:   return "DEPAUDIT";
2137     case DT_AUDIT:      return "AUDIT";
2138     case DT_PLTPAD:     return "PLTPAD";
2139     case DT_MOVETAB:    return "MOVETAB";
2140     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142     case DT_VERSYM:     return "VERSYM";
2143
2144     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146     case DT_RELACOUNT:  return "RELACOUNT";
2147     case DT_RELCOUNT:   return "RELCOUNT";
2148     case DT_FLAGS_1:    return "FLAGS_1";
2149     case DT_VERDEF:     return "VERDEF";
2150     case DT_VERDEFNUM:  return "VERDEFNUM";
2151     case DT_VERNEED:    return "VERNEED";
2152     case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154     case DT_AUXILIARY:  return "AUXILIARY";
2155     case DT_USED:       return "USED";
2156     case DT_FILTER:     return "FILTER";
2157
2158     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163     case DT_GNU_HASH:   return "GNU_HASH";
2164
2165     default:
2166       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167         {
2168           const char * result;
2169
2170           switch (filedata->file_header.e_machine)
2171             {
2172             case EM_MIPS:
2173             case EM_MIPS_RS3_LE:
2174               result = get_mips_dynamic_type (type);
2175               break;
2176             case EM_SPARCV9:
2177               result = get_sparc64_dynamic_type (type);
2178               break;
2179             case EM_PPC:
2180               result = get_ppc_dynamic_type (type);
2181               break;
2182             case EM_PPC64:
2183               result = get_ppc64_dynamic_type (type);
2184               break;
2185             case EM_IA_64:
2186               result = get_ia64_dynamic_type (type);
2187               break;
2188             case EM_ALPHA:
2189               result = get_alpha_dynamic_type (type);
2190               break;
2191             case EM_SCORE:
2192               result = get_score_dynamic_type (type);
2193               break;
2194             case EM_TI_C6000:
2195               result = get_tic6x_dynamic_type (type);
2196               break;
2197             case EM_ALTERA_NIOS2:
2198               result = get_nios2_dynamic_type (type);
2199               break;
2200             default:
2201               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202                 result = get_solaris_dynamic_type (type);
2203               else
2204                 result = NULL;
2205               break;
2206             }
2207
2208           if (result != NULL)
2209             return result;
2210
2211           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212         }
2213       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214                || (filedata->file_header.e_machine == EM_PARISC
2215                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216         {
2217           const char * result;
2218
2219           switch (filedata->file_header.e_machine)
2220             {
2221             case EM_PARISC:
2222               result = get_parisc_dynamic_type (type);
2223               break;
2224             case EM_IA_64:
2225               result = get_ia64_dynamic_type (type);
2226               break;
2227             default:
2228               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229                 result = get_solaris_dynamic_type (type);
2230               else
2231                 result = NULL;
2232               break;
2233             }
2234
2235           if (result != NULL)
2236             return result;
2237
2238           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239                     type);
2240         }
2241       else
2242         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244       return buff;
2245     }
2246 }
2247
2248 static char *
2249 get_file_type (unsigned e_type)
2250 {
2251   static char buff[32];
2252
2253   switch (e_type)
2254     {
2255     case ET_NONE: return _("NONE (None)");
2256     case ET_REL:  return _("REL (Relocatable file)");
2257     case ET_EXEC: return _("EXEC (Executable file)");
2258     case ET_DYN:  return _("DYN (Shared object file)");
2259     case ET_CORE: return _("CORE (Core file)");
2260
2261     default:
2262       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266       else
2267         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268       return buff;
2269     }
2270 }
2271
2272 static char *
2273 get_machine_name (unsigned e_machine)
2274 {
2275   static char buff[64]; /* XXX */
2276
2277   switch (e_machine)
2278     {
2279       /* Please keep this switch table sorted by increasing EM_ value.  */
2280       /* 0 */
2281     case EM_NONE:               return _("None");
2282     case EM_M32:                return "WE32100";
2283     case EM_SPARC:              return "Sparc";
2284     case EM_386:                return "Intel 80386";
2285     case EM_68K:                return "MC68000";
2286     case EM_88K:                return "MC88000";
2287     case EM_IAMCU:              return "Intel MCU";
2288     case EM_860:                return "Intel 80860";
2289     case EM_MIPS:               return "MIPS R3000";
2290     case EM_S370:               return "IBM System/370";
2291       /* 10 */
2292     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2293     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2294     case EM_PARISC:             return "HPPA";
2295     case EM_VPP550:             return "Fujitsu VPP500";
2296     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2297     case EM_960:                return "Intel 80960";
2298     case EM_PPC:                return "PowerPC";
2299       /* 20 */
2300     case EM_PPC64:              return "PowerPC64";
2301     case EM_S390_OLD:
2302     case EM_S390:               return "IBM S/390";
2303     case EM_SPU:                return "SPU";
2304       /* 30 */
2305     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2306     case EM_FR20:               return "Fujitsu FR20";
2307     case EM_RH32:               return "TRW RH32";
2308     case EM_MCORE:              return "MCORE";
2309       /* 40 */
2310     case EM_ARM:                return "ARM";
2311     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2312     case EM_SH:                 return "Renesas / SuperH SH";
2313     case EM_SPARCV9:            return "Sparc v9";
2314     case EM_TRICORE:            return "Siemens Tricore";
2315     case EM_ARC:                return "ARC";
2316     case EM_H8_300:             return "Renesas H8/300";
2317     case EM_H8_300H:            return "Renesas H8/300H";
2318     case EM_H8S:                return "Renesas H8S";
2319     case EM_H8_500:             return "Renesas H8/500";
2320       /* 50 */
2321     case EM_IA_64:              return "Intel IA-64";
2322     case EM_MIPS_X:             return "Stanford MIPS-X";
2323     case EM_COLDFIRE:           return "Motorola Coldfire";
2324     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2325     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2326     case EM_PCP:                return "Siemens PCP";
2327     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2328     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2329     case EM_STARCORE:           return "Motorola Star*Core processor";
2330     case EM_ME16:               return "Toyota ME16 processor";
2331       /* 60 */
2332     case EM_ST100:              return "STMicroelectronics ST100 processor";
2333     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2334     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2335     case EM_PDSP:               return "Sony DSP processor";
2336     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2337     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2338     case EM_FX66:               return "Siemens FX66 microcontroller";
2339     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2341     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2342       /* 70 */
2343     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2344     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2345     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2346     case EM_SVX:                return "Silicon Graphics SVx";
2347     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2348     case EM_VAX:                return "Digital VAX";
2349     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2350     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2351     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2352     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2353       /* 80 */
2354     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2355     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2356     case EM_PRISM:              return "Vitesse Prism";
2357     case EM_AVR_OLD:
2358     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2359     case EM_CYGNUS_FR30:
2360     case EM_FR30:               return "Fujitsu FR30";
2361     case EM_CYGNUS_D10V:
2362     case EM_D10V:               return "d10v";
2363     case EM_CYGNUS_D30V:
2364     case EM_D30V:               return "d30v";
2365     case EM_CYGNUS_V850:
2366     case EM_V850:               return "Renesas V850";
2367     case EM_CYGNUS_M32R:
2368     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2369     case EM_CYGNUS_MN10300:
2370     case EM_MN10300:            return "mn10300";
2371       /* 90 */
2372     case EM_CYGNUS_MN10200:
2373     case EM_MN10200:            return "mn10200";
2374     case EM_PJ:                 return "picoJava";
2375     case EM_OR1K:               return "OpenRISC 1000";
2376     case EM_ARC_COMPACT:        return "ARCompact";
2377     case EM_XTENSA_OLD:
2378     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2379     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2380     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2381     case EM_NS32K:              return "National Semiconductor 32000 series";
2382     case EM_TPC:                return "Tenor Network TPC processor";
2383     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2384       /* 100 */
2385     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2386     case EM_IP2K_OLD:
2387     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2388     case EM_MAX:                return "MAX Processor";
2389     case EM_CR:                 return "National Semiconductor CompactRISC";
2390     case EM_F2MC16:             return "Fujitsu F2MC16";
2391     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2392     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2393     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2394     case EM_SEP:                return "Sharp embedded microprocessor";
2395     case EM_ARCA:               return "Arca RISC microprocessor";
2396       /* 110 */
2397     case EM_UNICORE:            return "Unicore";
2398     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2399     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2400     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2401     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2402     case EM_XGATE:              return "Motorola XGATE embedded processor";
2403     case EM_C166:
2404     case EM_XC16X:              return "Infineon Technologies xc16x";
2405     case EM_M16C:               return "Renesas M16C series microprocessors";
2406     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2407     case EM_CE:                 return "Freescale Communication Engine RISC core";
2408       /* 120 */
2409     case EM_M32C:               return "Renesas M32c";
2410       /* 130 */
2411     case EM_TSK3000:            return "Altium TSK3000 core";
2412     case EM_RS08:               return "Freescale RS08 embedded processor";
2413     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2414     case EM_SCORE:              return "SUNPLUS S+Core";
2415     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2416     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2417     case EM_LATTICEMICO32:      return "Lattice Mico32";
2418     case EM_SE_C17:             return "Seiko Epson C17 family";
2419       /* 140 */
2420     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2421     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2422     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2423     case EM_TI_PRU:             return "TI PRU I/O processor";
2424       /* 160 */
2425     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2427     case EM_R32C:               return "Renesas R32C series microprocessors";
2428     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2429     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2430     case EM_8051:               return "Intel 8051 and variants";
2431     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2432     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2433     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2434     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435       /* 170 */
2436     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2437     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2438     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2439     case EM_RX:                 return "Renesas RX";
2440     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2441     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2442     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2443     case EM_CR16:
2444     case EM_MICROBLAZE:
2445     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2446     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2447     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2448       /* 180 */
2449     case EM_L1OM:               return "Intel L1OM";
2450     case EM_K1OM:               return "Intel K1OM";
2451     case EM_INTEL182:           return "Intel (reserved)";
2452     case EM_AARCH64:            return "AArch64";
2453     case EM_ARM184:             return "ARM (reserved)";
2454     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2455     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2456     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2457     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2458       /* 190 */
2459     case EM_CUDA:               return "NVIDIA CUDA architecture";
2460     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2461     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2462     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2463     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2464     case EM_ARC_COMPACT2:       return "ARCv2";
2465     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2466     case EM_RL78:               return "Renesas RL78";
2467     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2468     case EM_78K0R:              return "Renesas 78K0R";
2469       /* 200 */
2470     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2471     case EM_BA1:                return "Beyond BA1 CPU architecture";
2472     case EM_BA2:                return "Beyond BA2 CPU architecture";
2473     case EM_XCORE:              return "XMOS xCORE processor family";
2474     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2475       /* 210 */
2476     case EM_KM32:               return "KM211 KM32 32-bit processor";
2477     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2478     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2479     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2480     case EM_KVARC:              return "KM211 KVARC processor";
2481     case EM_CDP:                return "Paneve CDP architecture family";
2482     case EM_COGE:               return "Cognitive Smart Memory Processor";
2483     case EM_COOL:               return "Bluechip Systems CoolEngine";
2484     case EM_NORC:               return "Nanoradio Optimized RISC";
2485     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2486       /* 220 */
2487     case EM_Z80:                return "Zilog Z80";
2488     case EM_VISIUM:             return "CDS VISIUMcore processor";
2489     case EM_FT32:               return "FTDI Chip FT32";
2490     case EM_MOXIE:              return "Moxie";
2491     case EM_AMDGPU:             return "AMD GPU";
2492     case EM_RISCV:              return "RISC-V";
2493     case EM_LANAI:              return "Lanai 32-bit processor";
2494     case EM_BPF:                return "Linux BPF";
2495     case EM_NFP:                return "Netronome Flow Processor";
2496
2497       /* Large numbers...  */
2498     case EM_MT:                 return "Morpho Techologies MT processor";
2499     case EM_ALPHA:              return "Alpha";
2500     case EM_WEBASSEMBLY:        return "Web Assembly";
2501     case EM_DLX:                return "OpenDLX";
2502     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2503     case EM_IQ2000:             return "Vitesse IQ2000";
2504     case EM_M32C_OLD:
2505     case EM_NIOS32:             return "Altera Nios";
2506     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2507     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2508     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2509     case EM_S12Z:               return "Freescale S12Z";
2510     case EM_CSKY:               return "C-SKY";
2511
2512     default:
2513       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514       return buff;
2515     }
2516 }
2517
2518 static void
2519 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520 {
2521   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2522      other compilers don't a specific architecture type in the e_flags, and
2523      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525      architectures.
2526
2527      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528      but also sets a specific architecture type in the e_flags field.
2529
2530      However, when decoding the flags we don't worry if we see an
2531      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532      ARCEM architecture type.  */
2533
2534   switch (e_flags & EF_ARC_MACH_MSK)
2535     {
2536       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2537     case EF_ARC_CPU_ARCV2EM:
2538       strcat (buf, ", ARC EM");
2539       break;
2540     case EF_ARC_CPU_ARCV2HS:
2541       strcat (buf, ", ARC HS");
2542       break;
2543
2544       /* We only expect these to occur for EM_ARC_COMPACT.  */
2545     case E_ARC_MACH_ARC600:
2546       strcat (buf, ", ARC600");
2547       break;
2548     case E_ARC_MACH_ARC601:
2549       strcat (buf, ", ARC601");
2550       break;
2551     case E_ARC_MACH_ARC700:
2552       strcat (buf, ", ARC700");
2553       break;
2554
2555       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556          new ELF with new architecture being read by an old version of
2557          readelf, or (c) An ELF built with non-GNU compiler that does not
2558          set the architecture in the e_flags.  */
2559     default:
2560       if (e_machine == EM_ARC_COMPACT)
2561         strcat (buf, ", Unknown ARCompact");
2562       else
2563         strcat (buf, ", Unknown ARC");
2564       break;
2565     }
2566
2567   switch (e_flags & EF_ARC_OSABI_MSK)
2568     {
2569     case E_ARC_OSABI_ORIG:
2570       strcat (buf, ", (ABI:legacy)");
2571       break;
2572     case E_ARC_OSABI_V2:
2573       strcat (buf, ", (ABI:v2)");
2574       break;
2575       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2576     case E_ARC_OSABI_V3:
2577       strcat (buf, ", v3 no-legacy-syscalls ABI");
2578       break;
2579     case E_ARC_OSABI_V4:
2580       strcat (buf, ", v4 ABI");
2581       break;
2582     default:
2583       strcat (buf, ", unrecognised ARC OSABI flag");
2584       break;
2585     }
2586 }
2587
2588 static void
2589 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590 {
2591   unsigned eabi;
2592   bfd_boolean unknown = FALSE;
2593
2594   eabi = EF_ARM_EABI_VERSION (e_flags);
2595   e_flags &= ~ EF_ARM_EABIMASK;
2596
2597   /* Handle "generic" ARM flags.  */
2598   if (e_flags & EF_ARM_RELEXEC)
2599     {
2600       strcat (buf, ", relocatable executable");
2601       e_flags &= ~ EF_ARM_RELEXEC;
2602     }
2603
2604   if (e_flags & EF_ARM_PIC)
2605     {
2606       strcat (buf, ", position independent");
2607       e_flags &= ~ EF_ARM_PIC;
2608     }
2609
2610   /* Now handle EABI specific flags.  */
2611   switch (eabi)
2612     {
2613     default:
2614       strcat (buf, ", <unrecognized EABI>");
2615       if (e_flags)
2616         unknown = TRUE;
2617       break;
2618
2619     case EF_ARM_EABI_VER1:
2620       strcat (buf, ", Version1 EABI");
2621       while (e_flags)
2622         {
2623           unsigned flag;
2624
2625           /* Process flags one bit at a time.  */
2626           flag = e_flags & - e_flags;
2627           e_flags &= ~ flag;
2628
2629           switch (flag)
2630             {
2631             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2632               strcat (buf, ", sorted symbol tables");
2633               break;
2634
2635             default:
2636               unknown = TRUE;
2637               break;
2638             }
2639         }
2640       break;
2641
2642     case EF_ARM_EABI_VER2:
2643       strcat (buf, ", Version2 EABI");
2644       while (e_flags)
2645         {
2646           unsigned flag;
2647
2648           /* Process flags one bit at a time.  */
2649           flag = e_flags & - e_flags;
2650           e_flags &= ~ flag;
2651
2652           switch (flag)
2653             {
2654             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2655               strcat (buf, ", sorted symbol tables");
2656               break;
2657
2658             case EF_ARM_DYNSYMSUSESEGIDX:
2659               strcat (buf, ", dynamic symbols use segment index");
2660               break;
2661
2662             case EF_ARM_MAPSYMSFIRST:
2663               strcat (buf, ", mapping symbols precede others");
2664               break;
2665
2666             default:
2667               unknown = TRUE;
2668               break;
2669             }
2670         }
2671       break;
2672
2673     case EF_ARM_EABI_VER3:
2674       strcat (buf, ", Version3 EABI");
2675       break;
2676
2677     case EF_ARM_EABI_VER4:
2678       strcat (buf, ", Version4 EABI");
2679       while (e_flags)
2680         {
2681           unsigned flag;
2682
2683           /* Process flags one bit at a time.  */
2684           flag = e_flags & - e_flags;
2685           e_flags &= ~ flag;
2686
2687           switch (flag)
2688             {
2689             case EF_ARM_BE8:
2690               strcat (buf, ", BE8");
2691               break;
2692
2693             case EF_ARM_LE8:
2694               strcat (buf, ", LE8");
2695               break;
2696
2697             default:
2698               unknown = TRUE;
2699               break;
2700             }
2701         }
2702       break;
2703
2704     case EF_ARM_EABI_VER5:
2705       strcat (buf, ", Version5 EABI");
2706       while (e_flags)
2707         {
2708           unsigned flag;
2709
2710           /* Process flags one bit at a time.  */
2711           flag = e_flags & - e_flags;
2712           e_flags &= ~ flag;
2713
2714           switch (flag)
2715             {
2716             case EF_ARM_BE8:
2717               strcat (buf, ", BE8");
2718               break;
2719
2720             case EF_ARM_LE8:
2721               strcat (buf, ", LE8");
2722               break;
2723
2724             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2725               strcat (buf, ", soft-float ABI");
2726               break;
2727
2728             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2729               strcat (buf, ", hard-float ABI");
2730               break;
2731
2732             default:
2733               unknown = TRUE;
2734               break;
2735             }
2736         }
2737       break;
2738
2739     case EF_ARM_EABI_UNKNOWN:
2740       strcat (buf, ", GNU EABI");
2741       while (e_flags)
2742         {
2743           unsigned flag;
2744
2745           /* Process flags one bit at a time.  */
2746           flag = e_flags & - e_flags;
2747           e_flags &= ~ flag;
2748
2749           switch (flag)
2750             {
2751             case EF_ARM_INTERWORK:
2752               strcat (buf, ", interworking enabled");
2753               break;
2754
2755             case EF_ARM_APCS_26:
2756               strcat (buf, ", uses APCS/26");
2757               break;
2758
2759             case EF_ARM_APCS_FLOAT:
2760               strcat (buf, ", uses APCS/float");
2761               break;
2762
2763             case EF_ARM_PIC:
2764               strcat (buf, ", position independent");
2765               break;
2766
2767             case EF_ARM_ALIGN8:
2768               strcat (buf, ", 8 bit structure alignment");
2769               break;
2770
2771             case EF_ARM_NEW_ABI:
2772               strcat (buf, ", uses new ABI");
2773               break;
2774
2775             case EF_ARM_OLD_ABI:
2776               strcat (buf, ", uses old ABI");
2777               break;
2778
2779             case EF_ARM_SOFT_FLOAT:
2780               strcat (buf, ", software FP");
2781               break;
2782
2783             case EF_ARM_VFP_FLOAT:
2784               strcat (buf, ", VFP");
2785               break;
2786
2787             case EF_ARM_MAVERICK_FLOAT:
2788               strcat (buf, ", Maverick FP");
2789               break;
2790
2791             default:
2792               unknown = TRUE;
2793               break;
2794             }
2795         }
2796     }
2797
2798   if (unknown)
2799     strcat (buf,_(", <unknown>"));
2800 }
2801
2802 static void
2803 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804 {
2805   --size; /* Leave space for null terminator.  */
2806
2807   switch (e_flags & EF_AVR_MACH)
2808     {
2809     case E_AVR_MACH_AVR1:
2810       strncat (buf, ", avr:1", size);
2811       break;
2812     case E_AVR_MACH_AVR2:
2813       strncat (buf, ", avr:2", size);
2814       break;
2815     case E_AVR_MACH_AVR25:
2816       strncat (buf, ", avr:25", size);
2817       break;
2818     case E_AVR_MACH_AVR3:
2819       strncat (buf, ", avr:3", size);
2820       break;
2821     case E_AVR_MACH_AVR31:
2822       strncat (buf, ", avr:31", size);
2823       break;
2824     case E_AVR_MACH_AVR35:
2825       strncat (buf, ", avr:35", size);
2826       break;
2827     case E_AVR_MACH_AVR4:
2828       strncat (buf, ", avr:4", size);
2829       break;
2830     case E_AVR_MACH_AVR5:
2831       strncat (buf, ", avr:5", size);
2832       break;
2833     case E_AVR_MACH_AVR51:
2834       strncat (buf, ", avr:51", size);
2835       break;
2836     case E_AVR_MACH_AVR6:
2837       strncat (buf, ", avr:6", size);
2838       break;
2839     case E_AVR_MACH_AVRTINY:
2840       strncat (buf, ", avr:100", size);
2841       break;
2842     case E_AVR_MACH_XMEGA1:
2843       strncat (buf, ", avr:101", size);
2844       break;
2845     case E_AVR_MACH_XMEGA2:
2846       strncat (buf, ", avr:102", size);
2847       break;
2848     case E_AVR_MACH_XMEGA3:
2849       strncat (buf, ", avr:103", size);
2850       break;
2851     case E_AVR_MACH_XMEGA4:
2852       strncat (buf, ", avr:104", size);
2853       break;
2854     case E_AVR_MACH_XMEGA5:
2855       strncat (buf, ", avr:105", size);
2856       break;
2857     case E_AVR_MACH_XMEGA6:
2858       strncat (buf, ", avr:106", size);
2859       break;
2860     case E_AVR_MACH_XMEGA7:
2861       strncat (buf, ", avr:107", size);
2862       break;
2863     default:
2864       strncat (buf, ", avr:<unknown>", size);
2865       break;
2866     }
2867
2868   size -= strlen (buf);
2869   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870     strncat (buf, ", link-relax", size);
2871 }
2872
2873 static void
2874 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875 {
2876   unsigned abi;
2877   unsigned arch;
2878   unsigned config;
2879   unsigned version;
2880   bfd_boolean has_fpu = FALSE;
2881   unsigned int r = 0;
2882
2883   static const char *ABI_STRINGS[] =
2884   {
2885     "ABI v0", /* use r5 as return register; only used in N1213HC */
2886     "ABI v1", /* use r0 as return register */
2887     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888     "ABI v2fp", /* for FPU */
2889     "AABI",
2890     "ABI2 FP+"
2891   };
2892   static const char *VER_STRINGS[] =
2893   {
2894     "Andes ELF V1.3 or older",
2895     "Andes ELF V1.3.1",
2896     "Andes ELF V1.4"
2897   };
2898   static const char *ARCH_STRINGS[] =
2899   {
2900     "",
2901     "Andes Star v1.0",
2902     "Andes Star v2.0",
2903     "Andes Star v3.0",
2904     "Andes Star v3.0m"
2905   };
2906
2907   abi = EF_NDS_ABI & e_flags;
2908   arch = EF_NDS_ARCH & e_flags;
2909   config = EF_NDS_INST & e_flags;
2910   version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912   memset (buf, 0, size);
2913
2914   switch (abi)
2915     {
2916     case E_NDS_ABI_V0:
2917     case E_NDS_ABI_V1:
2918     case E_NDS_ABI_V2:
2919     case E_NDS_ABI_V2FP:
2920     case E_NDS_ABI_AABI:
2921     case E_NDS_ABI_V2FP_PLUS:
2922       /* In case there are holes in the array.  */
2923       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924       break;
2925
2926     default:
2927       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928       break;
2929     }
2930
2931   switch (version)
2932     {
2933     case E_NDS32_ELF_VER_1_2:
2934     case E_NDS32_ELF_VER_1_3:
2935     case E_NDS32_ELF_VER_1_4:
2936       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937       break;
2938
2939     default:
2940       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941       break;
2942     }
2943
2944   if (E_NDS_ABI_V0 == abi)
2945     {
2946       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2947       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948       if (arch == E_NDS_ARCH_STAR_V1_0)
2949         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950       return;
2951     }
2952
2953   switch (arch)
2954     {
2955     case E_NDS_ARCH_STAR_V1_0:
2956     case E_NDS_ARCH_STAR_V2_0:
2957     case E_NDS_ARCH_STAR_V3_0:
2958     case E_NDS_ARCH_STAR_V3_M:
2959       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960       break;
2961
2962     default:
2963       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964       /* ARCH version determines how the e_flags are interpreted.
2965          If it is unknown, we cannot proceed.  */
2966       return;
2967     }
2968
2969   /* Newer ABI; Now handle architecture specific flags.  */
2970   if (arch == E_NDS_ARCH_STAR_V1_0)
2971     {
2972       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976         r += snprintf (buf + r, size -r, ", MAC");
2977
2978       if (config & E_NDS32_HAS_DIV_INST)
2979         r += snprintf (buf + r, size -r, ", DIV");
2980
2981       if (config & E_NDS32_HAS_16BIT_INST)
2982         r += snprintf (buf + r, size -r, ", 16b");
2983     }
2984   else
2985     {
2986       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987         {
2988           if (version <= E_NDS32_ELF_VER_1_3)
2989             r += snprintf (buf + r, size -r, ", [B8]");
2990           else
2991             r += snprintf (buf + r, size -r, ", EX9");
2992         }
2993
2994       if (config & E_NDS32_HAS_MAC_DX_INST)
2995         r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997       if (config & E_NDS32_HAS_DIV_DX_INST)
2998         r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000       if (config & E_NDS32_HAS_16BIT_INST)
3001         {
3002           if (version <= E_NDS32_ELF_VER_1_3)
3003             r += snprintf (buf + r, size -r, ", 16b");
3004           else
3005             r += snprintf (buf + r, size -r, ", IFC");
3006         }
3007     }
3008
3009   if (config & E_NDS32_HAS_EXT_INST)
3010     r += snprintf (buf + r, size -r, ", PERF1");
3011
3012   if (config & E_NDS32_HAS_EXT2_INST)
3013     r += snprintf (buf + r, size -r, ", PERF2");
3014
3015   if (config & E_NDS32_HAS_FPU_INST)
3016     {
3017       has_fpu = TRUE;
3018       r += snprintf (buf + r, size -r, ", FPU_SP");
3019     }
3020
3021   if (config & E_NDS32_HAS_FPU_DP_INST)
3022     {
3023       has_fpu = TRUE;
3024       r += snprintf (buf + r, size -r, ", FPU_DP");
3025     }
3026
3027   if (config & E_NDS32_HAS_FPU_MAC_INST)
3028     {
3029       has_fpu = TRUE;
3030       r += snprintf (buf + r, size -r, ", FPU_MAC");
3031     }
3032
3033   if (has_fpu)
3034     {
3035       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036         {
3037         case E_NDS32_FPU_REG_8SP_4DP:
3038           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039           break;
3040         case E_NDS32_FPU_REG_16SP_8DP:
3041           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042           break;
3043         case E_NDS32_FPU_REG_32SP_16DP:
3044           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045           break;
3046         case E_NDS32_FPU_REG_32SP_32DP:
3047           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048           break;
3049         }
3050     }
3051
3052   if (config & E_NDS32_HAS_AUDIO_INST)
3053     r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055   if (config & E_NDS32_HAS_STRING_INST)
3056     r += snprintf (buf + r, size -r, ", STR");
3057
3058   if (config & E_NDS32_HAS_REDUCED_REGS)
3059     r += snprintf (buf + r, size -r, ", 16REG");
3060
3061   if (config & E_NDS32_HAS_VIDEO_INST)
3062     {
3063       if (version <= E_NDS32_ELF_VER_1_3)
3064         r += snprintf (buf + r, size -r, ", VIDEO");
3065       else
3066         r += snprintf (buf + r, size -r, ", SATURATION");
3067     }
3068
3069   if (config & E_NDS32_HAS_ENCRIPT_INST)
3070     r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072   if (config & E_NDS32_HAS_L2C_INST)
3073     r += snprintf (buf + r, size -r, ", L2C");
3074 }
3075
3076 static char *
3077 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078 {
3079   static char buf[1024];
3080
3081   buf[0] = '\0';
3082
3083   if (e_flags)
3084     {
3085       switch (e_machine)
3086         {
3087         default:
3088           break;
3089
3090         case EM_ARC_COMPACT2:
3091         case EM_ARC_COMPACT:
3092           decode_ARC_machine_flags (e_flags, e_machine, buf);
3093           break;
3094
3095         case EM_ARM:
3096           decode_ARM_machine_flags (e_flags, buf);
3097           break;
3098
3099         case EM_AVR:
3100           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101           break;
3102
3103         case EM_BLACKFIN:
3104           if (e_flags & EF_BFIN_PIC)
3105             strcat (buf, ", PIC");
3106
3107           if (e_flags & EF_BFIN_FDPIC)
3108             strcat (buf, ", FDPIC");
3109
3110           if (e_flags & EF_BFIN_CODE_IN_L1)
3111             strcat (buf, ", code in L1");
3112
3113           if (e_flags & EF_BFIN_DATA_IN_L1)
3114             strcat (buf, ", data in L1");
3115
3116           break;
3117
3118         case EM_CYGNUS_FRV:
3119           switch (e_flags & EF_FRV_CPU_MASK)
3120             {
3121             case EF_FRV_CPU_GENERIC:
3122               break;
3123
3124             default:
3125               strcat (buf, ", fr???");
3126               break;
3127
3128             case EF_FRV_CPU_FR300:
3129               strcat (buf, ", fr300");
3130               break;
3131
3132             case EF_FRV_CPU_FR400:
3133               strcat (buf, ", fr400");
3134               break;
3135             case EF_FRV_CPU_FR405:
3136               strcat (buf, ", fr405");
3137               break;
3138
3139             case EF_FRV_CPU_FR450:
3140               strcat (buf, ", fr450");
3141               break;
3142
3143             case EF_FRV_CPU_FR500:
3144               strcat (buf, ", fr500");
3145               break;
3146             case EF_FRV_CPU_FR550:
3147               strcat (buf, ", fr550");
3148               break;
3149
3150             case EF_FRV_CPU_SIMPLE:
3151               strcat (buf, ", simple");
3152               break;
3153             case EF_FRV_CPU_TOMCAT:
3154               strcat (buf, ", tomcat");
3155               break;
3156             }
3157           break;
3158
3159         case EM_68K:
3160           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161             strcat (buf, ", m68000");
3162           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163             strcat (buf, ", cpu32");
3164           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165             strcat (buf, ", fido_a");
3166           else
3167             {
3168               char const * isa = _("unknown");
3169               char const * mac = _("unknown mac");
3170               char const * additional = NULL;
3171
3172               switch (e_flags & EF_M68K_CF_ISA_MASK)
3173                 {
3174                 case EF_M68K_CF_ISA_A_NODIV:
3175                   isa = "A";
3176                   additional = ", nodiv";
3177                   break;
3178                 case EF_M68K_CF_ISA_A:
3179                   isa = "A";
3180                   break;
3181                 case EF_M68K_CF_ISA_A_PLUS:
3182                   isa = "A+";
3183                   break;
3184                 case EF_M68K_CF_ISA_B_NOUSP:
3185                   isa = "B";
3186                   additional = ", nousp";
3187                   break;
3188                 case EF_M68K_CF_ISA_B:
3189                   isa = "B";
3190                   break;
3191                 case EF_M68K_CF_ISA_C:
3192                   isa = "C";
3193                   break;
3194                 case EF_M68K_CF_ISA_C_NODIV:
3195                   isa = "C";
3196                   additional = ", nodiv";
3197                   break;
3198                 }
3199               strcat (buf, ", cf, isa ");
3200               strcat (buf, isa);
3201               if (additional)
3202                 strcat (buf, additional);
3203               if (e_flags & EF_M68K_CF_FLOAT)
3204                 strcat (buf, ", float");
3205               switch (e_flags & EF_M68K_CF_MAC_MASK)
3206                 {
3207                 case 0:
3208                   mac = NULL;
3209                   break;
3210                 case EF_M68K_CF_MAC:
3211                   mac = "mac";
3212                   break;
3213                 case EF_M68K_CF_EMAC:
3214                   mac = "emac";
3215                   break;
3216                 case EF_M68K_CF_EMAC_B:
3217                   mac = "emac_b";
3218                   break;
3219                 }
3220               if (mac)
3221                 {
3222                   strcat (buf, ", ");
3223                   strcat (buf, mac);
3224                 }
3225             }
3226           break;
3227
3228         case EM_CYGNUS_MEP:
3229           switch (e_flags & EF_MEP_CPU_MASK)
3230             {
3231             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238             }
3239
3240           switch (e_flags & EF_MEP_COP_MASK)
3241             {
3242             case EF_MEP_COP_NONE: break;
3243             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247             default: strcat (buf, _("<unknown MeP copro type>")); break;
3248             }
3249
3250           if (e_flags & EF_MEP_LIBRARY)
3251             strcat (buf, ", Built for Library");
3252
3253           if (e_flags & EF_MEP_INDEX_MASK)
3254             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255                      e_flags & EF_MEP_INDEX_MASK);
3256
3257           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259                      e_flags & ~ EF_MEP_ALL_FLAGS);
3260           break;
3261
3262         case EM_PPC:
3263           if (e_flags & EF_PPC_EMB)
3264             strcat (buf, ", emb");
3265
3266           if (e_flags & EF_PPC_RELOCATABLE)
3267             strcat (buf, _(", relocatable"));
3268
3269           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270             strcat (buf, _(", relocatable-lib"));
3271           break;
3272
3273         case EM_PPC64:
3274           if (e_flags & EF_PPC64_ABI)
3275             {
3276               char abi[] = ", abiv0";
3277
3278               abi[6] += e_flags & EF_PPC64_ABI;
3279               strcat (buf, abi);
3280             }
3281           break;
3282
3283         case EM_V800:
3284           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285             strcat (buf, ", RH850 ABI");
3286
3287           if (e_flags & EF_V800_850E3)
3288             strcat (buf, ", V3 architecture");
3289
3290           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291             strcat (buf, ", FPU not used");
3292
3293           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294             strcat (buf, ", regmode: COMMON");
3295
3296           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297             strcat (buf, ", r4 not used");
3298
3299           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300             strcat (buf, ", r30 not used");
3301
3302           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303             strcat (buf, ", r5 not used");
3304
3305           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306             strcat (buf, ", r2 not used");
3307
3308           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309             {
3310               switch (e_flags & - e_flags)
3311                 {
3312                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324                 default: break;
3325                 }
3326             }
3327           break;
3328
3329         case EM_V850:
3330         case EM_CYGNUS_V850:
3331           switch (e_flags & EF_V850_ARCH)
3332             {
3333             case E_V850E3V5_ARCH:
3334               strcat (buf, ", v850e3v5");
3335               break;
3336             case E_V850E2V3_ARCH:
3337               strcat (buf, ", v850e2v3");
3338               break;
3339             case E_V850E2_ARCH:
3340               strcat (buf, ", v850e2");
3341               break;
3342             case E_V850E1_ARCH:
3343               strcat (buf, ", v850e1");
3344               break;
3345             case E_V850E_ARCH:
3346               strcat (buf, ", v850e");
3347               break;
3348             case E_V850_ARCH:
3349               strcat (buf, ", v850");
3350               break;
3351             default:
3352               strcat (buf, _(", unknown v850 architecture variant"));
3353               break;
3354             }
3355           break;
3356
3357         case EM_M32R:
3358         case EM_CYGNUS_M32R:
3359           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360             strcat (buf, ", m32r");
3361           break;
3362
3363         case EM_MIPS:
3364         case EM_MIPS_RS3_LE:
3365           if (e_flags & EF_MIPS_NOREORDER)
3366             strcat (buf, ", noreorder");
3367
3368           if (e_flags & EF_MIPS_PIC)
3369             strcat (buf, ", pic");
3370
3371           if (e_flags & EF_MIPS_CPIC)
3372             strcat (buf, ", cpic");
3373
3374           if (e_flags & EF_MIPS_UCODE)
3375             strcat (buf, ", ugen_reserved");
3376
3377           if (e_flags & EF_MIPS_ABI2)
3378             strcat (buf, ", abi2");
3379
3380           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381             strcat (buf, ", odk first");
3382
3383           if (e_flags & EF_MIPS_32BITMODE)
3384             strcat (buf, ", 32bitmode");
3385
3386           if (e_flags & EF_MIPS_NAN2008)
3387             strcat (buf, ", nan2008");
3388
3389           if (e_flags & EF_MIPS_FP64)
3390             strcat (buf, ", fp64");
3391
3392           switch ((e_flags & EF_MIPS_MACH))
3393             {
3394             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3404             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3408             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3409             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3410             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3411             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3412             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3413             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3414             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3415             case 0:
3416             /* We simply ignore the field in this case to avoid confusion:
3417                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3418                extension.  */
3419               break;
3420             default: strcat (buf, _(", unknown CPU")); break;
3421             }
3422
3423           switch ((e_flags & EF_MIPS_ABI))
3424             {
3425             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3426             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3427             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3428             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3429             case 0:
3430             /* We simply ignore the field in this case to avoid confusion:
3431                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3432                This means it is likely to be an o32 file, but not for
3433                sure.  */
3434               break;
3435             default: strcat (buf, _(", unknown ABI")); break;
3436             }
3437
3438           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3439             strcat (buf, ", mdmx");
3440
3441           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3442             strcat (buf, ", mips16");
3443
3444           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3445             strcat (buf, ", micromips");
3446
3447           switch ((e_flags & EF_MIPS_ARCH))
3448             {
3449             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3450             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3451             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3452             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3453             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3454             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3455             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3456             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3457             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3458             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3459             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3460             default: strcat (buf, _(", unknown ISA")); break;
3461             }
3462           break;
3463
3464         case EM_NDS32:
3465           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3466           break;
3467
3468         case EM_NFP:
3469           switch (EF_NFP_MACH (e_flags))
3470             {
3471             case E_NFP_MACH_3200:
3472               strcat (buf, ", NFP-32xx");
3473               break;
3474             case E_NFP_MACH_6000:
3475               strcat (buf, ", NFP-6xxx");
3476               break;
3477             }
3478           break;
3479
3480         case EM_RISCV:
3481           if (e_flags & EF_RISCV_RVC)
3482             strcat (buf, ", RVC");
3483
3484           if (e_flags & EF_RISCV_RVE)
3485             strcat (buf, ", RVE");
3486
3487           switch (e_flags & EF_RISCV_FLOAT_ABI)
3488             {
3489             case EF_RISCV_FLOAT_ABI_SOFT:
3490               strcat (buf, ", soft-float ABI");
3491               break;
3492
3493             case EF_RISCV_FLOAT_ABI_SINGLE:
3494               strcat (buf, ", single-float ABI");
3495               break;
3496
3497             case EF_RISCV_FLOAT_ABI_DOUBLE:
3498               strcat (buf, ", double-float ABI");
3499               break;
3500
3501             case EF_RISCV_FLOAT_ABI_QUAD:
3502               strcat (buf, ", quad-float ABI");
3503               break;
3504             }
3505           break;
3506
3507         case EM_SH:
3508           switch ((e_flags & EF_SH_MACH_MASK))
3509             {
3510             case EF_SH1: strcat (buf, ", sh1"); break;
3511             case EF_SH2: strcat (buf, ", sh2"); break;
3512             case EF_SH3: strcat (buf, ", sh3"); break;
3513             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3514             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3515             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3516             case EF_SH3E: strcat (buf, ", sh3e"); break;
3517             case EF_SH4: strcat (buf, ", sh4"); break;
3518             case EF_SH5: strcat (buf, ", sh5"); break;
3519             case EF_SH2E: strcat (buf, ", sh2e"); break;
3520             case EF_SH4A: strcat (buf, ", sh4a"); break;
3521             case EF_SH2A: strcat (buf, ", sh2a"); break;
3522             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3523             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3524             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3525             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3526             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3527             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3528             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3529             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3530             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3531             default: strcat (buf, _(", unknown ISA")); break;
3532             }
3533
3534           if (e_flags & EF_SH_PIC)
3535             strcat (buf, ", pic");
3536
3537           if (e_flags & EF_SH_FDPIC)
3538             strcat (buf, ", fdpic");
3539           break;
3540
3541         case EM_OR1K:
3542           if (e_flags & EF_OR1K_NODELAY)
3543             strcat (buf, ", no delay");
3544           break;
3545
3546         case EM_SPARCV9:
3547           if (e_flags & EF_SPARC_32PLUS)
3548             strcat (buf, ", v8+");
3549
3550           if (e_flags & EF_SPARC_SUN_US1)
3551             strcat (buf, ", ultrasparcI");
3552
3553           if (e_flags & EF_SPARC_SUN_US3)
3554             strcat (buf, ", ultrasparcIII");
3555
3556           if (e_flags & EF_SPARC_HAL_R1)
3557             strcat (buf, ", halr1");
3558
3559           if (e_flags & EF_SPARC_LEDATA)
3560             strcat (buf, ", ledata");
3561
3562           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3563             strcat (buf, ", tso");
3564
3565           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3566             strcat (buf, ", pso");
3567
3568           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3569             strcat (buf, ", rmo");
3570           break;
3571
3572         case EM_PARISC:
3573           switch (e_flags & EF_PARISC_ARCH)
3574             {
3575             case EFA_PARISC_1_0:
3576               strcpy (buf, ", PA-RISC 1.0");
3577               break;
3578             case EFA_PARISC_1_1:
3579               strcpy (buf, ", PA-RISC 1.1");
3580               break;
3581             case EFA_PARISC_2_0:
3582               strcpy (buf, ", PA-RISC 2.0");
3583               break;
3584             default:
3585               break;
3586             }
3587           if (e_flags & EF_PARISC_TRAPNIL)
3588             strcat (buf, ", trapnil");
3589           if (e_flags & EF_PARISC_EXT)
3590             strcat (buf, ", ext");
3591           if (e_flags & EF_PARISC_LSB)
3592             strcat (buf, ", lsb");
3593           if (e_flags & EF_PARISC_WIDE)
3594             strcat (buf, ", wide");
3595           if (e_flags & EF_PARISC_NO_KABP)
3596             strcat (buf, ", no kabp");
3597           if (e_flags & EF_PARISC_LAZYSWAP)
3598             strcat (buf, ", lazyswap");
3599           break;
3600
3601         case EM_PJ:
3602         case EM_PJ_OLD:
3603           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3604             strcat (buf, ", new calling convention");
3605
3606           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3607             strcat (buf, ", gnu calling convention");
3608           break;
3609
3610         case EM_IA_64:
3611           if ((e_flags & EF_IA_64_ABI64))
3612             strcat (buf, ", 64-bit");
3613           else
3614             strcat (buf, ", 32-bit");
3615           if ((e_flags & EF_IA_64_REDUCEDFP))
3616             strcat (buf, ", reduced fp model");
3617           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3618             strcat (buf, ", no function descriptors, constant gp");
3619           else if ((e_flags & EF_IA_64_CONS_GP))
3620             strcat (buf, ", constant gp");
3621           if ((e_flags & EF_IA_64_ABSOLUTE))
3622             strcat (buf, ", absolute");
3623           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3624             {
3625               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3626                 strcat (buf, ", vms_linkages");
3627               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3628                 {
3629                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3630                   break;
3631                 case EF_IA_64_VMS_COMCOD_WARNING:
3632                   strcat (buf, ", warning");
3633                   break;
3634                 case EF_IA_64_VMS_COMCOD_ERROR:
3635                   strcat (buf, ", error");
3636                   break;
3637                 case EF_IA_64_VMS_COMCOD_ABORT:
3638                   strcat (buf, ", abort");
3639                   break;
3640                 default:
3641                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3642                         e_flags & EF_IA_64_VMS_COMCOD);
3643                   strcat (buf, ", <unknown>");
3644                 }
3645             }
3646           break;
3647
3648         case EM_VAX:
3649           if ((e_flags & EF_VAX_NONPIC))
3650             strcat (buf, ", non-PIC");
3651           if ((e_flags & EF_VAX_DFLOAT))
3652             strcat (buf, ", D-Float");
3653           if ((e_flags & EF_VAX_GFLOAT))
3654             strcat (buf, ", G-Float");
3655           break;
3656
3657         case EM_VISIUM:
3658           if (e_flags & EF_VISIUM_ARCH_MCM)
3659             strcat (buf, ", mcm");
3660           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3661             strcat (buf, ", mcm24");
3662           if (e_flags & EF_VISIUM_ARCH_GR6)
3663             strcat (buf, ", gr6");
3664           break;
3665
3666         case EM_RL78:
3667           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3668             {
3669             case E_FLAG_RL78_ANY_CPU: break;
3670             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3671             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3672             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3673             }
3674           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3675             strcat (buf, ", 64-bit doubles");
3676           break;
3677
3678         case EM_RX:
3679           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3680             strcat (buf, ", 64-bit doubles");
3681           if (e_flags & E_FLAG_RX_DSP)
3682             strcat (buf, ", dsp");
3683           if (e_flags & E_FLAG_RX_PID)
3684             strcat (buf, ", pid");
3685           if (e_flags & E_FLAG_RX_ABI)
3686             strcat (buf, ", RX ABI");
3687           if (e_flags & E_FLAG_RX_SINSNS_SET)
3688             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3689                     ? ", uses String instructions" : ", bans String instructions");
3690           if (e_flags & E_FLAG_RX_V2)
3691             strcat (buf, ", V2");
3692           break;
3693
3694         case EM_S390:
3695           if (e_flags & EF_S390_HIGH_GPRS)
3696             strcat (buf, ", highgprs");
3697           break;
3698
3699         case EM_TI_C6000:
3700           if ((e_flags & EF_C6000_REL))
3701             strcat (buf, ", relocatable module");
3702           break;
3703
3704         case EM_MSP430:
3705           strcat (buf, _(": architecture variant: "));
3706           switch (e_flags & EF_MSP430_MACH)
3707             {
3708             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3709             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3710             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3711             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3712             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3713             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3714             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3715             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3716             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3717             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3718             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3719             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3720             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3721             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3722             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3723             default:
3724               strcat (buf, _(": unknown")); break;
3725             }
3726
3727           if (e_flags & ~ EF_MSP430_MACH)
3728             strcat (buf, _(": unknown extra flag bits also present"));
3729         }
3730     }
3731
3732   return buf;
3733 }
3734
3735 static const char *
3736 get_osabi_name (Filedata * filedata, unsigned int osabi)
3737 {
3738   static char buff[32];
3739
3740   switch (osabi)
3741     {
3742     case ELFOSABI_NONE:         return "UNIX - System V";
3743     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3744     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3745     case ELFOSABI_GNU:          return "UNIX - GNU";
3746     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3747     case ELFOSABI_AIX:          return "UNIX - AIX";
3748     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3749     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3750     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3751     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3752     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3753     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3754     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3755     case ELFOSABI_AROS:         return "AROS";
3756     case ELFOSABI_FENIXOS:      return "FenixOS";
3757     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3758     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3759     default:
3760       if (osabi >= 64)
3761         switch (filedata->file_header.e_machine)
3762           {
3763           case EM_ARM:
3764             switch (osabi)
3765               {
3766               case ELFOSABI_ARM:        return "ARM";
3767               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3768               default:
3769                 break;
3770               }
3771             break;
3772
3773           case EM_MSP430:
3774           case EM_MSP430_OLD:
3775           case EM_VISIUM:
3776             switch (osabi)
3777               {
3778               case ELFOSABI_STANDALONE: return _("Standalone App");
3779               default:
3780                 break;
3781               }
3782             break;
3783
3784           case EM_TI_C6000:
3785             switch (osabi)
3786               {
3787               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3788               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3789               default:
3790                 break;
3791               }
3792             break;
3793
3794           default:
3795             break;
3796           }
3797       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3798       return buff;
3799     }
3800 }
3801
3802 static const char *
3803 get_aarch64_segment_type (unsigned long type)
3804 {
3805   switch (type)
3806     {
3807     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3808     default:                  return NULL;
3809     }
3810 }
3811
3812 static const char *
3813 get_arm_segment_type (unsigned long type)
3814 {
3815   switch (type)
3816     {
3817     case PT_ARM_EXIDX: return "EXIDX";
3818     default:           return NULL;
3819     }
3820 }
3821
3822 static const char *
3823 get_s390_segment_type (unsigned long type)
3824 {
3825   switch (type)
3826     {
3827     case PT_S390_PGSTE: return "S390_PGSTE";
3828     default:            return NULL;
3829     }
3830 }
3831
3832 static const char *
3833 get_mips_segment_type (unsigned long type)
3834 {
3835   switch (type)
3836     {
3837     case PT_MIPS_REGINFO:   return "REGINFO";
3838     case PT_MIPS_RTPROC:    return "RTPROC";
3839     case PT_MIPS_OPTIONS:   return "OPTIONS";
3840     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3841     default:                return NULL;
3842     }
3843 }
3844
3845 static const char *
3846 get_parisc_segment_type (unsigned long type)
3847 {
3848   switch (type)
3849     {
3850     case PT_HP_TLS:             return "HP_TLS";
3851     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3852     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3853     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3854     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3855     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3856     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3857     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3858     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3859     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3860     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3861     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3862     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3863     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3864     case PT_HP_STACK:           return "HP_STACK";
3865     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3866     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3867     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3868     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3869     default:                    return NULL;
3870     }
3871 }
3872
3873 static const char *
3874 get_ia64_segment_type (unsigned long type)
3875 {
3876   switch (type)
3877     {
3878     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3879     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3880     case PT_HP_TLS:             return "HP_TLS";
3881     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3882     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3883     case PT_IA_64_HP_STACK:     return "HP_STACK";
3884     default:                    return NULL;
3885     }
3886 }
3887
3888 static const char *
3889 get_tic6x_segment_type (unsigned long type)
3890 {
3891   switch (type)
3892     {
3893     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3894     default:               return NULL;
3895     }
3896 }
3897
3898 static const char *
3899 get_solaris_segment_type (unsigned long type)
3900 {
3901   switch (type)
3902     {
3903     case 0x6464e550: return "PT_SUNW_UNWIND";
3904     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3905     case 0x6ffffff7: return "PT_LOSUNW";
3906     case 0x6ffffffa: return "PT_SUNWBSS";
3907     case 0x6ffffffb: return "PT_SUNWSTACK";
3908     case 0x6ffffffc: return "PT_SUNWDTRACE";
3909     case 0x6ffffffd: return "PT_SUNWCAP";
3910     case 0x6fffffff: return "PT_HISUNW";
3911     default:         return NULL;
3912     }
3913 }
3914
3915 static const char *
3916 get_segment_type (Filedata * filedata, unsigned long p_type)
3917 {
3918   static char buff[32];
3919
3920   switch (p_type)
3921     {
3922     case PT_NULL:       return "NULL";
3923     case PT_LOAD:       return "LOAD";
3924     case PT_DYNAMIC:    return "DYNAMIC";
3925     case PT_INTERP:     return "INTERP";
3926     case PT_NOTE:       return "NOTE";
3927     case PT_SHLIB:      return "SHLIB";
3928     case PT_PHDR:       return "PHDR";
3929     case PT_TLS:        return "TLS";
3930     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3931     case PT_GNU_STACK:  return "GNU_STACK";
3932     case PT_GNU_RELRO:  return "GNU_RELRO";
3933
3934     default:
3935       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3936         {
3937           sprintf (buff, "GNU_MBIND+%#lx",
3938                    p_type - PT_GNU_MBIND_LO);
3939         }
3940       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3941         {
3942           const char * result;
3943
3944           switch (filedata->file_header.e_machine)
3945             {
3946             case EM_AARCH64:
3947               result = get_aarch64_segment_type (p_type);
3948               break;
3949             case EM_ARM:
3950               result = get_arm_segment_type (p_type);
3951               break;
3952             case EM_MIPS:
3953             case EM_MIPS_RS3_LE:
3954               result = get_mips_segment_type (p_type);
3955               break;
3956             case EM_PARISC:
3957               result = get_parisc_segment_type (p_type);
3958               break;
3959             case EM_IA_64:
3960               result = get_ia64_segment_type (p_type);
3961               break;
3962             case EM_TI_C6000:
3963               result = get_tic6x_segment_type (p_type);
3964               break;
3965             case EM_S390:
3966             case EM_S390_OLD:
3967               result = get_s390_segment_type (p_type);
3968               break;
3969             default:
3970               result = NULL;
3971               break;
3972             }
3973
3974           if (result != NULL)
3975             return result;
3976
3977           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3978         }
3979       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3980         {
3981           const char * result;
3982
3983           switch (filedata->file_header.e_machine)
3984             {
3985             case EM_PARISC:
3986               result = get_parisc_segment_type (p_type);
3987               break;
3988             case EM_IA_64:
3989               result = get_ia64_segment_type (p_type);
3990               break;
3991             default:
3992               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3993                 result = get_solaris_segment_type (p_type);
3994               else
3995                 result = NULL;
3996               break;
3997             }
3998
3999           if (result != NULL)
4000             return result;
4001
4002           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4003         }
4004       else
4005         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4006
4007       return buff;
4008     }
4009 }
4010
4011 static const char *
4012 get_arc_section_type_name (unsigned int sh_type)
4013 {
4014   switch (sh_type)
4015     {
4016     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4017     default:
4018       break;
4019     }
4020   return NULL;
4021 }
4022
4023 static const char *
4024 get_mips_section_type_name (unsigned int sh_type)
4025 {
4026   switch (sh_type)
4027     {
4028     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4029     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4030     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4031     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4032     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4033     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4034     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4035     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4036     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4037     case SHT_MIPS_RELD:          return "MIPS_RELD";
4038     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4039     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4040     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4041     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4042     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4043     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4044     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4045     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4046     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4047     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4048     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4049     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4050     case SHT_MIPS_LINE:          return "MIPS_LINE";
4051     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4052     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4053     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4054     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4055     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4056     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4057     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4058     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4059     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4060     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4061     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4062     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4063     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4064     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4065     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4066     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4067     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4068     default:
4069       break;
4070     }
4071   return NULL;
4072 }
4073
4074 static const char *
4075 get_parisc_section_type_name (unsigned int sh_type)
4076 {
4077   switch (sh_type)
4078     {
4079     case SHT_PARISC_EXT:        return "PARISC_EXT";
4080     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4081     case SHT_PARISC_DOC:        return "PARISC_DOC";
4082     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4083     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4084     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4085     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4086     default:                    return NULL;
4087     }
4088 }
4089
4090 static const char *
4091 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4092 {
4093   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4094   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4095     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4096
4097   switch (sh_type)
4098     {
4099     case SHT_IA_64_EXT:                return "IA_64_EXT";
4100     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4101     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4102     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4103     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4104     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4105     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4106     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4107     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4108     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4109     default:
4110       break;
4111     }
4112   return NULL;
4113 }
4114
4115 static const char *
4116 get_x86_64_section_type_name (unsigned int sh_type)
4117 {
4118   switch (sh_type)
4119     {
4120     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4121     default:                    return NULL;
4122     }
4123 }
4124
4125 static const char *
4126 get_aarch64_section_type_name (unsigned int sh_type)
4127 {
4128   switch (sh_type)
4129     {
4130     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4131     default:                     return NULL;
4132     }
4133 }
4134
4135 static const char *
4136 get_arm_section_type_name (unsigned int sh_type)
4137 {
4138   switch (sh_type)
4139     {
4140     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4141     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4142     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4143     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4144     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4145     default:                      return NULL;
4146     }
4147 }
4148
4149 static const char *
4150 get_tic6x_section_type_name (unsigned int sh_type)
4151 {
4152   switch (sh_type)
4153     {
4154     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4155     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4156     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4157     case SHT_TI_ICODE:          return "TI_ICODE";
4158     case SHT_TI_XREF:           return "TI_XREF";
4159     case SHT_TI_HANDLER:        return "TI_HANDLER";
4160     case SHT_TI_INITINFO:       return "TI_INITINFO";
4161     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4162     default:                    return NULL;
4163     }
4164 }
4165
4166 static const char *
4167 get_msp430x_section_type_name (unsigned int sh_type)
4168 {
4169   switch (sh_type)
4170     {
4171     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4172     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4173     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4174     default:                      return NULL;
4175     }
4176 }
4177
4178 static const char *
4179 get_nfp_section_type_name (unsigned int sh_type)
4180 {
4181   switch (sh_type)
4182     {
4183     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4184     case SHT_NFP_INITREG:       return "NFP_INITREG";
4185     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4186     default:                    return NULL;
4187     }
4188 }
4189
4190 static const char *
4191 get_v850_section_type_name (unsigned int sh_type)
4192 {
4193   switch (sh_type)
4194     {
4195     case SHT_V850_SCOMMON:  return "V850 Small Common";
4196     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4197     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4198     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4199     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4200     default:                return NULL;
4201     }
4202 }
4203
4204 static const char *
4205 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4206 {
4207   static char buff[32];
4208   const char * result;
4209
4210   switch (sh_type)
4211     {
4212     case SHT_NULL:              return "NULL";
4213     case SHT_PROGBITS:          return "PROGBITS";
4214     case SHT_SYMTAB:            return "SYMTAB";
4215     case SHT_STRTAB:            return "STRTAB";
4216     case SHT_RELA:              return "RELA";
4217     case SHT_HASH:              return "HASH";
4218     case SHT_DYNAMIC:           return "DYNAMIC";
4219     case SHT_NOTE:              return "NOTE";
4220     case SHT_NOBITS:            return "NOBITS";
4221     case SHT_REL:               return "REL";
4222     case SHT_SHLIB:             return "SHLIB";
4223     case SHT_DYNSYM:            return "DYNSYM";
4224     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4225     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4226     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4227     case SHT_GNU_HASH:          return "GNU_HASH";
4228     case SHT_GROUP:             return "GROUP";
4229     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4230     case SHT_GNU_verdef:        return "VERDEF";
4231     case SHT_GNU_verneed:       return "VERNEED";
4232     case SHT_GNU_versym:        return "VERSYM";
4233     case 0x6ffffff0:            return "VERSYM";
4234     case 0x6ffffffc:            return "VERDEF";
4235     case 0x7ffffffd:            return "AUXILIARY";
4236     case 0x7fffffff:            return "FILTER";
4237     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4238
4239     default:
4240       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4241         {
4242           switch (filedata->file_header.e_machine)
4243             {
4244             case EM_ARC:
4245             case EM_ARC_COMPACT:
4246             case EM_ARC_COMPACT2:
4247               result = get_arc_section_type_name (sh_type);
4248               break;
4249             case EM_MIPS:
4250             case EM_MIPS_RS3_LE:
4251               result = get_mips_section_type_name (sh_type);
4252               break;
4253             case EM_PARISC:
4254               result = get_parisc_section_type_name (sh_type);
4255               break;
4256             case EM_IA_64:
4257               result = get_ia64_section_type_name (filedata, sh_type);
4258               break;
4259             case EM_X86_64:
4260             case EM_L1OM:
4261             case EM_K1OM:
4262               result = get_x86_64_section_type_name (sh_type);
4263               break;
4264             case EM_AARCH64:
4265               result = get_aarch64_section_type_name (sh_type);
4266               break;
4267             case EM_ARM:
4268               result = get_arm_section_type_name (sh_type);
4269               break;
4270             case EM_TI_C6000:
4271               result = get_tic6x_section_type_name (sh_type);
4272               break;
4273             case EM_MSP430:
4274               result = get_msp430x_section_type_name (sh_type);
4275               break;
4276             case EM_NFP:
4277               result = get_nfp_section_type_name (sh_type);
4278               break;
4279             case EM_V800:
4280             case EM_V850:
4281             case EM_CYGNUS_V850:
4282               result = get_v850_section_type_name (sh_type);
4283               break;
4284             default:
4285               result = NULL;
4286               break;
4287             }
4288
4289           if (result != NULL)
4290             return result;
4291
4292           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4293         }
4294       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4295         {
4296           switch (filedata->file_header.e_machine)
4297             {
4298             case EM_IA_64:
4299               result = get_ia64_section_type_name (filedata, sh_type);
4300               break;
4301             default:
4302               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4303                 result = get_solaris_section_type (sh_type);
4304               else
4305                 {
4306                   switch (sh_type)
4307                     {
4308                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4309                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4310                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4311                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4312                     default:
4313                       result = NULL;
4314                       break;
4315                     }
4316                 }
4317               break;
4318             }
4319
4320           if (result != NULL)
4321             return result;
4322
4323           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4324         }
4325       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4326         {
4327           switch (filedata->file_header.e_machine)
4328             {
4329             case EM_V800:
4330             case EM_V850:
4331             case EM_CYGNUS_V850:
4332               result = get_v850_section_type_name (sh_type);
4333               break;
4334             default:
4335               result = NULL;
4336               break;
4337             }
4338
4339           if (result != NULL)
4340             return result;
4341
4342           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4343         }
4344       else
4345         /* This message is probably going to be displayed in a 15
4346            character wide field, so put the hex value first.  */
4347         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4348
4349       return buff;
4350     }
4351 }
4352
4353 #define OPTION_DEBUG_DUMP       512
4354 #define OPTION_DYN_SYMS         513
4355 #define OPTION_DWARF_DEPTH      514
4356 #define OPTION_DWARF_START      515
4357 #define OPTION_DWARF_CHECK      516
4358
4359 static struct option options[] =
4360 {
4361   {"all",              no_argument, 0, 'a'},
4362   {"file-header",      no_argument, 0, 'h'},
4363   {"program-headers",  no_argument, 0, 'l'},
4364   {"headers",          no_argument, 0, 'e'},
4365   {"histogram",        no_argument, 0, 'I'},
4366   {"segments",         no_argument, 0, 'l'},
4367   {"sections",         no_argument, 0, 'S'},
4368   {"section-headers",  no_argument, 0, 'S'},
4369   {"section-groups",   no_argument, 0, 'g'},
4370   {"section-details",  no_argument, 0, 't'},
4371   {"full-section-name",no_argument, 0, 'N'},
4372   {"symbols",          no_argument, 0, 's'},
4373   {"syms",             no_argument, 0, 's'},
4374   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4375   {"relocs",           no_argument, 0, 'r'},
4376   {"notes",            no_argument, 0, 'n'},
4377   {"dynamic",          no_argument, 0, 'd'},
4378   {"arch-specific",    no_argument, 0, 'A'},
4379   {"version-info",     no_argument, 0, 'V'},
4380   {"use-dynamic",      no_argument, 0, 'D'},
4381   {"unwind",           no_argument, 0, 'u'},
4382   {"archive-index",    no_argument, 0, 'c'},
4383   {"hex-dump",         required_argument, 0, 'x'},
4384   {"relocated-dump",   required_argument, 0, 'R'},
4385   {"string-dump",      required_argument, 0, 'p'},
4386   {"decompress",       no_argument, 0, 'z'},
4387 #ifdef SUPPORT_DISASSEMBLY
4388   {"instruction-dump", required_argument, 0, 'i'},
4389 #endif
4390   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4391
4392   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4393   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4394   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4395
4396   {"version",          no_argument, 0, 'v'},
4397   {"wide",             no_argument, 0, 'W'},
4398   {"help",             no_argument, 0, 'H'},
4399   {0,                  no_argument, 0, 0}
4400 };
4401
4402 static void
4403 usage (FILE * stream)
4404 {
4405   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4406   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4407   fprintf (stream, _(" Options are:\n\
4408   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4409   -h --file-header       Display the ELF file header\n\
4410   -l --program-headers   Display the program headers\n\
4411      --segments          An alias for --program-headers\n\
4412   -S --section-headers   Display the sections' header\n\
4413      --sections          An alias for --section-headers\n\
4414   -g --section-groups    Display the section groups\n\
4415   -t --section-details   Display the section details\n\
4416   -e --headers           Equivalent to: -h -l -S\n\
4417   -s --syms              Display the symbol table\n\
4418      --symbols           An alias for --syms\n\
4419   --dyn-syms             Display the dynamic symbol table\n\
4420   -n --notes             Display the core notes (if present)\n\
4421   -r --relocs            Display the relocations (if present)\n\
4422   -u --unwind            Display the unwind info (if present)\n\
4423   -d --dynamic           Display the dynamic section (if present)\n\
4424   -V --version-info      Display the version sections (if present)\n\
4425   -A --arch-specific     Display architecture specific information (if any)\n\
4426   -c --archive-index     Display the symbol/file index in an archive\n\
4427   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4428   -x --hex-dump=<number|name>\n\
4429                          Dump the contents of section <number|name> as bytes\n\
4430   -p --string-dump=<number|name>\n\
4431                          Dump the contents of section <number|name> as strings\n\
4432   -R --relocated-dump=<number|name>\n\
4433                          Dump the contents of section <number|name> as relocated bytes\n\
4434   -z --decompress        Decompress section before dumping it\n\
4435   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4436   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4437                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4438                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4439                =addr,=cu_index,=links,=follow-links]\n\
4440                          Display the contents of DWARF debug sections\n"));
4441   fprintf (stream, _("\
4442   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4443   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4444                          or deeper\n"));
4445 #ifdef SUPPORT_DISASSEMBLY
4446   fprintf (stream, _("\
4447   -i --instruction-dump=<number|name>\n\
4448                          Disassemble the contents of section <number|name>\n"));
4449 #endif
4450   fprintf (stream, _("\
4451   -I --histogram         Display histogram of bucket list lengths\n\
4452   -W --wide              Allow output width to exceed 80 characters\n\
4453   @<file>                Read options from <file>\n\
4454   -H --help              Display this information\n\
4455   -v --version           Display the version number of readelf\n"));
4456
4457   if (REPORT_BUGS_TO[0] && stream == stdout)
4458     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4459
4460   exit (stream == stdout ? 0 : 1);
4461 }
4462
4463 /* Record the fact that the user wants the contents of section number
4464    SECTION to be displayed using the method(s) encoded as flags bits
4465    in TYPE.  Note, TYPE can be zero if we are creating the array for
4466    the first time.  */
4467
4468 static void
4469 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4470 {
4471   if (section >= filedata->num_dump_sects)
4472     {
4473       dump_type * new_dump_sects;
4474
4475       new_dump_sects = (dump_type *) calloc (section + 1,
4476                                              sizeof (* new_dump_sects));
4477
4478       if (new_dump_sects == NULL)
4479         error (_("Out of memory allocating dump request table.\n"));
4480       else
4481         {
4482           if (filedata->dump_sects)
4483             {
4484               /* Copy current flag settings.  */
4485               memcpy (new_dump_sects, filedata->dump_sects,
4486                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4487
4488               free (filedata->dump_sects);
4489             }
4490
4491           filedata->dump_sects = new_dump_sects;
4492           filedata->num_dump_sects = section + 1;
4493         }
4494     }
4495
4496   if (filedata->dump_sects)
4497     filedata->dump_sects[section] |= type;
4498 }
4499
4500 /* Request a dump by section name.  */
4501
4502 static void
4503 request_dump_byname (const char * section, dump_type type)
4504 {
4505   struct dump_list_entry * new_request;
4506
4507   new_request = (struct dump_list_entry *)
4508       malloc (sizeof (struct dump_list_entry));
4509   if (!new_request)
4510     error (_("Out of memory allocating dump request table.\n"));
4511
4512   new_request->name = strdup (section);
4513   if (!new_request->name)
4514     error (_("Out of memory allocating dump request table.\n"));
4515
4516   new_request->type = type;
4517
4518   new_request->next = dump_sects_byname;
4519   dump_sects_byname = new_request;
4520 }
4521
4522 static inline void
4523 request_dump (Filedata * filedata, dump_type type)
4524 {
4525   int section;
4526   char * cp;
4527
4528   do_dump++;
4529   section = strtoul (optarg, & cp, 0);
4530
4531   if (! *cp && section >= 0)
4532     request_dump_bynumber (filedata, section, type);
4533   else
4534     request_dump_byname (optarg, type);
4535 }
4536
4537 static void
4538 parse_args (Filedata * filedata, int argc, char ** argv)
4539 {
4540   int c;
4541
4542   if (argc < 2)
4543     usage (stderr);
4544
4545   while ((c = getopt_long
4546           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4547     {
4548       switch (c)
4549         {
4550         case 0:
4551           /* Long options.  */
4552           break;
4553         case 'H':
4554           usage (stdout);
4555           break;
4556
4557         case 'a':
4558           do_syms = TRUE;
4559           do_reloc = TRUE;
4560           do_unwind = TRUE;
4561           do_dynamic = TRUE;
4562           do_header = TRUE;
4563           do_sections = TRUE;
4564           do_section_groups = TRUE;
4565           do_segments = TRUE;
4566           do_version = TRUE;
4567           do_histogram = TRUE;
4568           do_arch = TRUE;
4569           do_notes = TRUE;
4570           break;
4571         case 'g':
4572           do_section_groups = TRUE;
4573           break;
4574         case 't':
4575         case 'N':
4576           do_sections = TRUE;
4577           do_section_details = TRUE;
4578           break;
4579         case 'e':
4580           do_header = TRUE;
4581           do_sections = TRUE;
4582           do_segments = TRUE;
4583           break;
4584         case 'A':
4585           do_arch = TRUE;
4586           break;
4587         case 'D':
4588           do_using_dynamic = TRUE;
4589           break;
4590         case 'r':
4591           do_reloc = TRUE;
4592           break;
4593         case 'u':
4594           do_unwind = TRUE;
4595           break;
4596         case 'h':
4597           do_header = TRUE;
4598           break;
4599         case 'l':
4600           do_segments = TRUE;
4601           break;
4602         case 's':
4603           do_syms = TRUE;
4604           break;
4605         case 'S':
4606           do_sections = TRUE;
4607           break;
4608         case 'd':
4609           do_dynamic = TRUE;
4610           break;
4611         case 'I':
4612           do_histogram = TRUE;
4613           break;
4614         case 'n':
4615           do_notes = TRUE;
4616           break;
4617         case 'c':
4618           do_archive_index = TRUE;
4619           break;
4620         case 'x':
4621           request_dump (filedata, HEX_DUMP);
4622           break;
4623         case 'p':
4624           request_dump (filedata, STRING_DUMP);
4625           break;
4626         case 'R':
4627           request_dump (filedata, RELOC_DUMP);
4628           break;
4629         case 'z':
4630           decompress_dumps = TRUE;
4631           break;
4632         case 'w':
4633           do_dump = TRUE;
4634           if (optarg == 0)
4635             {
4636               do_debugging = TRUE;
4637               dwarf_select_sections_all ();
4638             }
4639           else
4640             {
4641               do_debugging = FALSE;
4642               dwarf_select_sections_by_letters (optarg);
4643             }
4644           break;
4645         case OPTION_DEBUG_DUMP:
4646           do_dump = TRUE;
4647           if (optarg == 0)
4648             do_debugging = TRUE;
4649           else
4650             {
4651               do_debugging = FALSE;
4652               dwarf_select_sections_by_names (optarg);
4653             }
4654           break;
4655         case OPTION_DWARF_DEPTH:
4656           {
4657             char *cp;
4658
4659             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4660           }
4661           break;
4662         case OPTION_DWARF_START:
4663           {
4664             char *cp;
4665
4666             dwarf_start_die = strtoul (optarg, & cp, 0);
4667           }
4668           break;
4669         case OPTION_DWARF_CHECK:
4670           dwarf_check = TRUE;
4671           break;
4672         case OPTION_DYN_SYMS:
4673           do_dyn_syms = TRUE;
4674           break;
4675 #ifdef SUPPORT_DISASSEMBLY
4676         case 'i':
4677           request_dump (filedata, DISASS_DUMP);
4678           break;
4679 #endif
4680         case 'v':
4681           print_version (program_name);
4682           break;
4683         case 'V':
4684           do_version = TRUE;
4685           break;
4686         case 'W':
4687           do_wide = TRUE;
4688           break;
4689         default:
4690           /* xgettext:c-format */
4691           error (_("Invalid option '-%c'\n"), c);
4692           /* Fall through.  */
4693         case '?':
4694           usage (stderr);
4695         }
4696     }
4697
4698   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4699       && !do_segments && !do_header && !do_dump && !do_version
4700       && !do_histogram && !do_debugging && !do_arch && !do_notes
4701       && !do_section_groups && !do_archive_index
4702       && !do_dyn_syms)
4703     usage (stderr);
4704 }
4705
4706 static const char *
4707 get_elf_class (unsigned int elf_class)
4708 {
4709   static char buff[32];
4710
4711   switch (elf_class)
4712     {
4713     case ELFCLASSNONE: return _("none");
4714     case ELFCLASS32:   return "ELF32";
4715     case ELFCLASS64:   return "ELF64";
4716     default:
4717       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4718       return buff;
4719     }
4720 }
4721
4722 static const char *
4723 get_data_encoding (unsigned int encoding)
4724 {
4725   static char buff[32];
4726
4727   switch (encoding)
4728     {
4729     case ELFDATANONE: return _("none");
4730     case ELFDATA2LSB: return _("2's complement, little endian");
4731     case ELFDATA2MSB: return _("2's complement, big endian");
4732     default:
4733       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4734       return buff;
4735     }
4736 }
4737
4738 /* Decode the data held in 'filedata->file_header'.  */
4739
4740 static bfd_boolean
4741 process_file_header (Filedata * filedata)
4742 {
4743   Elf_Internal_Ehdr * header = & filedata->file_header;
4744
4745   if (   header->e_ident[EI_MAG0] != ELFMAG0
4746       || header->e_ident[EI_MAG1] != ELFMAG1
4747       || header->e_ident[EI_MAG2] != ELFMAG2
4748       || header->e_ident[EI_MAG3] != ELFMAG3)
4749     {
4750       error
4751         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4752       return FALSE;
4753     }
4754
4755   init_dwarf_regnames (header->e_machine);
4756
4757   if (do_header)
4758     {
4759       unsigned i;
4760
4761       printf (_("ELF Header:\n"));
4762       printf (_("  Magic:   "));
4763       for (i = 0; i < EI_NIDENT; i++)
4764         printf ("%2.2x ", header->e_ident[i]);
4765       printf ("\n");
4766       printf (_("  Class:                             %s\n"),
4767               get_elf_class (header->e_ident[EI_CLASS]));
4768       printf (_("  Data:                              %s\n"),
4769               get_data_encoding (header->e_ident[EI_DATA]));
4770       printf (_("  Version:                           %d%s\n"),
4771               header->e_ident[EI_VERSION],
4772               (header->e_ident[EI_VERSION] == EV_CURRENT
4773                ? _(" (current)")
4774                : (header->e_ident[EI_VERSION] != EV_NONE
4775                   ? _(" <unknown>")
4776                   : "")));
4777       printf (_("  OS/ABI:                            %s\n"),
4778               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4779       printf (_("  ABI Version:                       %d\n"),
4780               header->e_ident[EI_ABIVERSION]);
4781       printf (_("  Type:                              %s\n"),
4782               get_file_type (header->e_type));
4783       printf (_("  Machine:                           %s\n"),
4784               get_machine_name (header->e_machine));
4785       printf (_("  Version:                           0x%lx\n"),
4786               header->e_version);
4787
4788       printf (_("  Entry point address:               "));
4789       print_vma (header->e_entry, PREFIX_HEX);
4790       printf (_("\n  Start of program headers:          "));
4791       print_vma (header->e_phoff, DEC);
4792       printf (_(" (bytes into file)\n  Start of section headers:          "));
4793       print_vma (header->e_shoff, DEC);
4794       printf (_(" (bytes into file)\n"));
4795
4796       printf (_("  Flags:                             0x%lx%s\n"),
4797               header->e_flags,
4798               get_machine_flags (filedata, header->e_flags, header->e_machine));
4799       printf (_("  Size of this header:               %u (bytes)\n"),
4800               header->e_ehsize);
4801       printf (_("  Size of program headers:           %u (bytes)\n"),
4802               header->e_phentsize);
4803       printf (_("  Number of program headers:         %u"),
4804               header->e_phnum);
4805       if (filedata->section_headers != NULL
4806           && header->e_phnum == PN_XNUM
4807           && filedata->section_headers[0].sh_info != 0)
4808         {
4809           header->e_phnum = filedata->section_headers[0].sh_info;
4810           printf (" (%u)", header->e_phnum);
4811         }
4812       putc ('\n', stdout);
4813       printf (_("  Size of section headers:           %u (bytes)\n"),
4814               header->e_shentsize);
4815       printf (_("  Number of section headers:         %u"),
4816               header->e_shnum);
4817       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4818         {
4819           header->e_shnum = filedata->section_headers[0].sh_size;
4820           printf (" (%u)", header->e_shnum);
4821         }
4822       putc ('\n', stdout);
4823       printf (_("  Section header string table index: %u"),
4824               header->e_shstrndx);
4825       if (filedata->section_headers != NULL
4826           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4827         {
4828           header->e_shstrndx = filedata->section_headers[0].sh_link;
4829           printf (" (%u)", header->e_shstrndx);
4830         }
4831       if (header->e_shstrndx != SHN_UNDEF
4832           && header->e_shstrndx >= header->e_shnum)
4833         {
4834           header->e_shstrndx = SHN_UNDEF;
4835           printf (_(" <corrupt: out of range>"));
4836         }
4837       putc ('\n', stdout);
4838     }
4839
4840   if (filedata->section_headers != NULL)
4841     {
4842       if (header->e_phnum == PN_XNUM
4843           && filedata->section_headers[0].sh_info != 0)
4844         header->e_phnum = filedata->section_headers[0].sh_info;
4845       if (header->e_shnum == SHN_UNDEF)
4846         header->e_shnum = filedata->section_headers[0].sh_size;
4847       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4848         header->e_shstrndx = filedata->section_headers[0].sh_link;
4849       if (header->e_shstrndx >= header->e_shnum)
4850         header->e_shstrndx = SHN_UNDEF;
4851       free (filedata->section_headers);
4852       filedata->section_headers = NULL;
4853     }
4854
4855   return TRUE;
4856 }
4857
4858 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4859    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4860
4861 static bfd_boolean
4862 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4863 {
4864   Elf32_External_Phdr * phdrs;
4865   Elf32_External_Phdr * external;
4866   Elf_Internal_Phdr *   internal;
4867   unsigned int i;
4868   unsigned int size = filedata->file_header.e_phentsize;
4869   unsigned int num  = filedata->file_header.e_phnum;
4870
4871   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4872   if (size == 0 || num == 0)
4873     return FALSE;
4874   if (size < sizeof * phdrs)
4875     {
4876       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4877       return FALSE;
4878     }
4879   if (size > sizeof * phdrs)
4880     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4881
4882   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4883                                             size, num, _("program headers"));
4884   if (phdrs == NULL)
4885     return FALSE;
4886
4887   for (i = 0, internal = pheaders, external = phdrs;
4888        i < filedata->file_header.e_phnum;
4889        i++, internal++, external++)
4890     {
4891       internal->p_type   = BYTE_GET (external->p_type);
4892       internal->p_offset = BYTE_GET (external->p_offset);
4893       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4894       internal->p_paddr  = BYTE_GET (external->p_paddr);
4895       internal->p_filesz = BYTE_GET (external->p_filesz);
4896       internal->p_memsz  = BYTE_GET (external->p_memsz);
4897       internal->p_flags  = BYTE_GET (external->p_flags);
4898       internal->p_align  = BYTE_GET (external->p_align);
4899     }
4900
4901   free (phdrs);
4902   return TRUE;
4903 }
4904
4905 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4906    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4907
4908 static bfd_boolean
4909 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4910 {
4911   Elf64_External_Phdr * phdrs;
4912   Elf64_External_Phdr * external;
4913   Elf_Internal_Phdr *   internal;
4914   unsigned int i;
4915   unsigned int size = filedata->file_header.e_phentsize;
4916   unsigned int num  = filedata->file_header.e_phnum;
4917
4918   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4919   if (size == 0 || num == 0)
4920     return FALSE;
4921   if (size < sizeof * phdrs)
4922     {
4923       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4924       return FALSE;
4925     }
4926   if (size > sizeof * phdrs)
4927     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4928
4929   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4930                                             size, num, _("program headers"));
4931   if (!phdrs)
4932     return FALSE;
4933
4934   for (i = 0, internal = pheaders, external = phdrs;
4935        i < filedata->file_header.e_phnum;
4936        i++, internal++, external++)
4937     {
4938       internal->p_type   = BYTE_GET (external->p_type);
4939       internal->p_flags  = BYTE_GET (external->p_flags);
4940       internal->p_offset = BYTE_GET (external->p_offset);
4941       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4942       internal->p_paddr  = BYTE_GET (external->p_paddr);
4943       internal->p_filesz = BYTE_GET (external->p_filesz);
4944       internal->p_memsz  = BYTE_GET (external->p_memsz);
4945       internal->p_align  = BYTE_GET (external->p_align);
4946     }
4947
4948   free (phdrs);
4949   return TRUE;
4950 }
4951
4952 /* Returns TRUE if the program headers were read into `program_headers'.  */
4953
4954 static bfd_boolean
4955 get_program_headers (Filedata * filedata)
4956 {
4957   Elf_Internal_Phdr * phdrs;
4958
4959   /* Check cache of prior read.  */
4960   if (filedata->program_headers != NULL)
4961     return TRUE;
4962
4963   /* Be kind to memory checkers by looking for
4964      e_phnum values which we know must be invalid.  */
4965   if (filedata->file_header.e_phnum
4966       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4967       >= filedata->file_size)
4968     {
4969       error (_("Too many program headers - %#x - the file is not that big\n"),
4970              filedata->file_header.e_phnum);
4971       return FALSE;
4972     }
4973
4974   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4975                                          sizeof (Elf_Internal_Phdr));
4976   if (phdrs == NULL)
4977     {
4978       error (_("Out of memory reading %u program headers\n"),
4979              filedata->file_header.e_phnum);
4980       return FALSE;
4981     }
4982
4983   if (is_32bit_elf
4984       ? get_32bit_program_headers (filedata, phdrs)
4985       : get_64bit_program_headers (filedata, phdrs))
4986     {
4987       filedata->program_headers = phdrs;
4988       return TRUE;
4989     }
4990
4991   free (phdrs);
4992   return FALSE;
4993 }
4994
4995 /* Returns TRUE if the program headers were loaded.  */
4996
4997 static bfd_boolean
4998 process_program_headers (Filedata * filedata)
4999 {
5000   Elf_Internal_Phdr * segment;
5001   unsigned int i;
5002   Elf_Internal_Phdr * previous_load = NULL;
5003
5004   if (filedata->file_header.e_phnum == 0)
5005     {
5006       /* PR binutils/12467.  */
5007       if (filedata->file_header.e_phoff != 0)
5008         {
5009           warn (_("possibly corrupt ELF header - it has a non-zero program"
5010                   " header offset, but no program headers\n"));
5011           return FALSE;
5012         }
5013       else if (do_segments)
5014         printf (_("\nThere are no program headers in this file.\n"));
5015       return TRUE;
5016     }
5017
5018   if (do_segments && !do_header)
5019     {
5020       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5021       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5022       printf (ngettext ("There is %d program header, starting at offset %s\n",
5023                         "There are %d program headers, starting at offset %s\n",
5024                         filedata->file_header.e_phnum),
5025               filedata->file_header.e_phnum,
5026               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5027     }
5028
5029   if (! get_program_headers (filedata))
5030     return TRUE;
5031
5032   if (do_segments)
5033     {
5034       if (filedata->file_header.e_phnum > 1)
5035         printf (_("\nProgram Headers:\n"));
5036       else
5037         printf (_("\nProgram Headers:\n"));
5038
5039       if (is_32bit_elf)
5040         printf
5041           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5042       else if (do_wide)
5043         printf
5044           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5045       else
5046         {
5047           printf
5048             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5049           printf
5050             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5051         }
5052     }
5053
5054   dynamic_addr = 0;
5055   dynamic_size = 0;
5056
5057   for (i = 0, segment = filedata->program_headers;
5058        i < filedata->file_header.e_phnum;
5059        i++, segment++)
5060     {
5061       if (do_segments)
5062         {
5063           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5064
5065           if (is_32bit_elf)
5066             {
5067               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5068               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5069               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5070               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5071               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5072               printf ("%c%c%c ",
5073                       (segment->p_flags & PF_R ? 'R' : ' '),
5074                       (segment->p_flags & PF_W ? 'W' : ' '),
5075                       (segment->p_flags & PF_X ? 'E' : ' '));
5076               printf ("%#lx", (unsigned long) segment->p_align);
5077             }
5078           else if (do_wide)
5079             {
5080               if ((unsigned long) segment->p_offset == segment->p_offset)
5081                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5082               else
5083                 {
5084                   print_vma (segment->p_offset, FULL_HEX);
5085                   putchar (' ');
5086                 }
5087
5088               print_vma (segment->p_vaddr, FULL_HEX);
5089               putchar (' ');
5090               print_vma (segment->p_paddr, FULL_HEX);
5091               putchar (' ');
5092
5093               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5094                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5095               else
5096                 {
5097                   print_vma (segment->p_filesz, FULL_HEX);
5098                   putchar (' ');
5099                 }
5100
5101               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5102                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5103               else
5104                 {
5105                   print_vma (segment->p_memsz, FULL_HEX);
5106                 }
5107
5108               printf (" %c%c%c ",
5109                       (segment->p_flags & PF_R ? 'R' : ' '),
5110                       (segment->p_flags & PF_W ? 'W' : ' '),
5111                       (segment->p_flags & PF_X ? 'E' : ' '));
5112
5113               if ((unsigned long) segment->p_align == segment->p_align)
5114                 printf ("%#lx", (unsigned long) segment->p_align);
5115               else
5116                 {
5117                   print_vma (segment->p_align, PREFIX_HEX);
5118                 }
5119             }
5120           else
5121             {
5122               print_vma (segment->p_offset, FULL_HEX);
5123               putchar (' ');
5124               print_vma (segment->p_vaddr, FULL_HEX);
5125               putchar (' ');
5126               print_vma (segment->p_paddr, FULL_HEX);
5127               printf ("\n                 ");
5128               print_vma (segment->p_filesz, FULL_HEX);
5129               putchar (' ');
5130               print_vma (segment->p_memsz, FULL_HEX);
5131               printf ("  %c%c%c    ",
5132                       (segment->p_flags & PF_R ? 'R' : ' '),
5133                       (segment->p_flags & PF_W ? 'W' : ' '),
5134                       (segment->p_flags & PF_X ? 'E' : ' '));
5135               print_vma (segment->p_align, PREFIX_HEX);
5136             }
5137
5138           putc ('\n', stdout);
5139         }
5140
5141       switch (segment->p_type)
5142         {
5143         case PT_LOAD:
5144 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5145          required by the ELF standard, several programs, including the Linux
5146          kernel, make use of non-ordered segments.  */
5147           if (previous_load
5148               && previous_load->p_vaddr > segment->p_vaddr)
5149             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5150 #endif
5151           if (segment->p_memsz < segment->p_filesz)
5152             error (_("the segment's file size is larger than its memory size\n"));
5153           previous_load = segment;
5154           break;
5155
5156         case PT_PHDR:
5157           /* PR 20815 - Verify that the program header is loaded into memory.  */
5158           if (i > 0 && previous_load != NULL)
5159             error (_("the PHDR segment must occur before any LOAD segment\n"));
5160           if (filedata->file_header.e_machine != EM_PARISC)
5161             {
5162               unsigned int j;
5163
5164               for (j = 1; j < filedata->file_header.e_phnum; j++)
5165                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5166                     && (filedata->program_headers[j].p_vaddr
5167                         + filedata->program_headers[j].p_memsz)
5168                     >= (segment->p_vaddr + segment->p_filesz))
5169                   break;
5170               if (j == filedata->file_header.e_phnum)
5171                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5172             }
5173           break;
5174
5175         case PT_DYNAMIC:
5176           if (dynamic_addr)
5177             error (_("more than one dynamic segment\n"));
5178
5179           /* By default, assume that the .dynamic section is the first
5180              section in the DYNAMIC segment.  */
5181           dynamic_addr = segment->p_offset;
5182           dynamic_size = segment->p_filesz;
5183
5184           /* Try to locate the .dynamic section. If there is
5185              a section header table, we can easily locate it.  */
5186           if (filedata->section_headers != NULL)
5187             {
5188               Elf_Internal_Shdr * sec;
5189
5190               sec = find_section (filedata, ".dynamic");
5191               if (sec == NULL || sec->sh_size == 0)
5192                 {
5193                   /* A corresponding .dynamic section is expected, but on
5194                      IA-64/OpenVMS it is OK for it to be missing.  */
5195                   if (!is_ia64_vms (filedata))
5196                     error (_("no .dynamic section in the dynamic segment\n"));
5197                   break;
5198                 }
5199
5200               if (sec->sh_type == SHT_NOBITS)
5201                 {
5202                   dynamic_size = 0;
5203                   break;
5204                 }
5205
5206               dynamic_addr = sec->sh_offset;
5207               dynamic_size = sec->sh_size;
5208
5209               if (dynamic_addr < segment->p_offset
5210                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5211                 warn (_("the .dynamic section is not contained"
5212                         " within the dynamic segment\n"));
5213               else if (dynamic_addr > segment->p_offset)
5214                 warn (_("the .dynamic section is not the first section"
5215                         " in the dynamic segment.\n"));
5216             }
5217
5218           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5219              segment.  Check this after matching against the section headers
5220              so we don't warn on debuginfo file (which have NOBITS .dynamic
5221              sections).  */
5222           if (dynamic_addr + dynamic_size >= filedata->file_size)
5223             {
5224               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5225               dynamic_addr = dynamic_size = 0;
5226             }
5227           break;
5228
5229         case PT_INTERP:
5230           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5231                      SEEK_SET))
5232             error (_("Unable to find program interpreter name\n"));
5233           else
5234             {
5235               char fmt [32];
5236               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5237
5238               if (ret >= (int) sizeof (fmt) || ret < 0)
5239                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5240
5241               program_interpreter[0] = 0;
5242               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5243                 error (_("Unable to read program interpreter name\n"));
5244
5245               if (do_segments)
5246                 printf (_("      [Requesting program interpreter: %s]\n"),
5247                     program_interpreter);
5248             }
5249           break;
5250         }
5251     }
5252
5253   if (do_segments
5254       && filedata->section_headers != NULL
5255       && filedata->string_table != NULL)
5256     {
5257       printf (_("\n Section to Segment mapping:\n"));
5258       printf (_("  Segment Sections...\n"));
5259
5260       for (i = 0; i < filedata->file_header.e_phnum; i++)
5261         {
5262           unsigned int j;
5263           Elf_Internal_Shdr * section;
5264
5265           segment = filedata->program_headers + i;
5266           section = filedata->section_headers + 1;
5267
5268           printf ("   %2.2d     ", i);
5269
5270           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5271             {
5272               if (!ELF_TBSS_SPECIAL (section, segment)
5273                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5274                 printf ("%s ", printable_section_name (filedata, section));
5275             }
5276
5277           putc ('\n',stdout);
5278         }
5279     }
5280
5281   return TRUE;
5282 }
5283
5284
5285 /* Find the file offset corresponding to VMA by using the program headers.  */
5286
5287 static long
5288 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5289 {
5290   Elf_Internal_Phdr * seg;
5291
5292   if (! get_program_headers (filedata))
5293     {
5294       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5295       return (long) vma;
5296     }
5297
5298   for (seg = filedata->program_headers;
5299        seg < filedata->program_headers + filedata->file_header.e_phnum;
5300        ++seg)
5301     {
5302       if (seg->p_type != PT_LOAD)
5303         continue;
5304
5305       if (vma >= (seg->p_vaddr & -seg->p_align)
5306           && vma + size <= seg->p_vaddr + seg->p_filesz)
5307         return vma - seg->p_vaddr + seg->p_offset;
5308     }
5309
5310   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5311         (unsigned long) vma);
5312   return (long) vma;
5313 }
5314
5315
5316 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5317    If PROBE is true, this is just a probe and we do not generate any error
5318    messages if the load fails.  */
5319
5320 static bfd_boolean
5321 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5322 {
5323   Elf32_External_Shdr * shdrs;
5324   Elf_Internal_Shdr *   internal;
5325   unsigned int          i;
5326   unsigned int          size = filedata->file_header.e_shentsize;
5327   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5328
5329   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5330   if (size == 0 || num == 0)
5331     return FALSE;
5332   if (size < sizeof * shdrs)
5333     {
5334       if (! probe)
5335         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336       return FALSE;
5337     }
5338   if (!probe && size > sizeof * shdrs)
5339     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5340
5341   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5342                                             size, num,
5343                                             probe ? NULL : _("section headers"));
5344   if (shdrs == NULL)
5345     return FALSE;
5346
5347   free (filedata->section_headers);
5348   filedata->section_headers = (Elf_Internal_Shdr *)
5349     cmalloc (num, sizeof (Elf_Internal_Shdr));
5350   if (filedata->section_headers == NULL)
5351     {
5352       if (!probe)
5353         error (_("Out of memory reading %u section headers\n"), num);
5354       free (shdrs);
5355       return FALSE;
5356     }
5357
5358   for (i = 0, internal = filedata->section_headers;
5359        i < num;
5360        i++, internal++)
5361     {
5362       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5363       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5364       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5365       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5366       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5367       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5368       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5369       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5370       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5371       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5372       if (!probe && internal->sh_link > num)
5373         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5374       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5375         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5376     }
5377
5378   free (shdrs);
5379   return TRUE;
5380 }
5381
5382 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5383
5384 static bfd_boolean
5385 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5386 {
5387   Elf64_External_Shdr *  shdrs;
5388   Elf_Internal_Shdr *    internal;
5389   unsigned int           i;
5390   unsigned int           size = filedata->file_header.e_shentsize;
5391   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5392
5393   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5394   if (size == 0 || num == 0)
5395     return FALSE;
5396
5397   if (size < sizeof * shdrs)
5398     {
5399       if (! probe)
5400         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5401       return FALSE;
5402     }
5403
5404   if (! probe && size > sizeof * shdrs)
5405     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5406
5407   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5408                                             filedata->file_header.e_shoff,
5409                                             size, num,
5410                                             probe ? NULL : _("section headers"));
5411   if (shdrs == NULL)
5412     return FALSE;
5413
5414   free (filedata->section_headers);
5415   filedata->section_headers = (Elf_Internal_Shdr *)
5416     cmalloc (num, sizeof (Elf_Internal_Shdr));
5417   if (filedata->section_headers == NULL)
5418     {
5419       if (! probe)
5420         error (_("Out of memory reading %u section headers\n"), num);
5421       free (shdrs);
5422       return FALSE;
5423     }
5424
5425   for (i = 0, internal = filedata->section_headers;
5426        i < num;
5427        i++, internal++)
5428     {
5429       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5430       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5431       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5432       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5433       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5434       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5435       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5436       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5437       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5438       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5439       if (!probe && internal->sh_link > num)
5440         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5441       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5442         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5443     }
5444
5445   free (shdrs);
5446   return TRUE;
5447 }
5448
5449 static Elf_Internal_Sym *
5450 get_32bit_elf_symbols (Filedata *           filedata,
5451                        Elf_Internal_Shdr *  section,
5452                        unsigned long *      num_syms_return)
5453 {
5454   unsigned long number = 0;
5455   Elf32_External_Sym * esyms = NULL;
5456   Elf_External_Sym_Shndx * shndx = NULL;
5457   Elf_Internal_Sym * isyms = NULL;
5458   Elf_Internal_Sym * psym;
5459   unsigned int j;
5460   elf_section_list * entry;
5461
5462   if (section->sh_size == 0)
5463     {
5464       if (num_syms_return != NULL)
5465         * num_syms_return = 0;
5466       return NULL;
5467     }
5468
5469   /* Run some sanity checks first.  */
5470   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5471     {
5472       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5473              printable_section_name (filedata, section),
5474              (unsigned long) section->sh_entsize);
5475       goto exit_point;
5476     }
5477
5478   if (section->sh_size > filedata->file_size)
5479     {
5480       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5481              printable_section_name (filedata, section),
5482              (unsigned long) section->sh_size);
5483       goto exit_point;
5484     }
5485
5486   number = section->sh_size / section->sh_entsize;
5487
5488   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5489     {
5490       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5491              (unsigned long) section->sh_size,
5492              printable_section_name (filedata, section),
5493              (unsigned long) section->sh_entsize);
5494       goto exit_point;
5495     }
5496
5497   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5498                                            section->sh_size, _("symbols"));
5499   if (esyms == NULL)
5500     goto exit_point;
5501
5502   shndx = NULL;
5503   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5504     {
5505       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5506         continue;
5507
5508       if (shndx != NULL)
5509         {
5510           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5511           free (shndx);
5512         }
5513
5514       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5515                                                    entry->hdr->sh_offset,
5516                                                    1, entry->hdr->sh_size,
5517                                                    _("symbol table section indices"));
5518       if (shndx == NULL)
5519         goto exit_point;
5520
5521       /* PR17531: file: heap-buffer-overflow */
5522       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5523         {
5524           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5525                  printable_section_name (filedata, entry->hdr),
5526                  (unsigned long) entry->hdr->sh_size,
5527                  (unsigned long) section->sh_size);
5528           goto exit_point;
5529         }
5530     }
5531
5532   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5533
5534   if (isyms == NULL)
5535     {
5536       error (_("Out of memory reading %lu symbols\n"),
5537              (unsigned long) number);
5538       goto exit_point;
5539     }
5540
5541   for (j = 0, psym = isyms; j < number; j++, psym++)
5542     {
5543       psym->st_name  = BYTE_GET (esyms[j].st_name);
5544       psym->st_value = BYTE_GET (esyms[j].st_value);
5545       psym->st_size  = BYTE_GET (esyms[j].st_size);
5546       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5547       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5548         psym->st_shndx
5549           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5550       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5551         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5552       psym->st_info  = BYTE_GET (esyms[j].st_info);
5553       psym->st_other = BYTE_GET (esyms[j].st_other);
5554     }
5555
5556  exit_point:
5557   free (shndx);
5558   free (esyms);
5559
5560   if (num_syms_return != NULL)
5561     * num_syms_return = isyms == NULL ? 0 : number;
5562
5563   return isyms;
5564 }
5565
5566 static Elf_Internal_Sym *
5567 get_64bit_elf_symbols (Filedata *           filedata,
5568                        Elf_Internal_Shdr *  section,
5569                        unsigned long *      num_syms_return)
5570 {
5571   unsigned long number = 0;
5572   Elf64_External_Sym * esyms = NULL;
5573   Elf_External_Sym_Shndx * shndx = NULL;
5574   Elf_Internal_Sym * isyms = NULL;
5575   Elf_Internal_Sym * psym;
5576   unsigned int j;
5577   elf_section_list * entry;
5578
5579   if (section->sh_size == 0)
5580     {
5581       if (num_syms_return != NULL)
5582         * num_syms_return = 0;
5583       return NULL;
5584     }
5585
5586   /* Run some sanity checks first.  */
5587   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5588     {
5589       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5590              printable_section_name (filedata, section),
5591              (unsigned long) section->sh_entsize);
5592       goto exit_point;
5593     }
5594
5595   if (section->sh_size > filedata->file_size)
5596     {
5597       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5598              printable_section_name (filedata, section),
5599              (unsigned long) section->sh_size);
5600       goto exit_point;
5601     }
5602
5603   number = section->sh_size / section->sh_entsize;
5604
5605   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5606     {
5607       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5608              (unsigned long) section->sh_size,
5609              printable_section_name (filedata, section),
5610              (unsigned long) section->sh_entsize);
5611       goto exit_point;
5612     }
5613
5614   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5615                                            section->sh_size, _("symbols"));
5616   if (!esyms)
5617     goto exit_point;
5618
5619   shndx = NULL;
5620   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5621     {
5622       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5623         continue;
5624
5625       if (shndx != NULL)
5626         {
5627           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5628           free (shndx);
5629         }
5630
5631       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5632                                                    entry->hdr->sh_offset,
5633                                                    1, entry->hdr->sh_size,
5634                                                    _("symbol table section indices"));
5635       if (shndx == NULL)
5636         goto exit_point;
5637
5638       /* PR17531: file: heap-buffer-overflow */
5639       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5640         {
5641           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5642                  printable_section_name (filedata, entry->hdr),
5643                  (unsigned long) entry->hdr->sh_size,
5644                  (unsigned long) section->sh_size);
5645           goto exit_point;
5646         }
5647     }
5648
5649   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5650
5651   if (isyms == NULL)
5652     {
5653       error (_("Out of memory reading %lu symbols\n"),
5654              (unsigned long) number);
5655       goto exit_point;
5656     }
5657
5658   for (j = 0, psym = isyms; j < number; j++, psym++)
5659     {
5660       psym->st_name  = BYTE_GET (esyms[j].st_name);
5661       psym->st_info  = BYTE_GET (esyms[j].st_info);
5662       psym->st_other = BYTE_GET (esyms[j].st_other);
5663       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5664
5665       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5666         psym->st_shndx
5667           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5668       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5669         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5670
5671       psym->st_value = BYTE_GET (esyms[j].st_value);
5672       psym->st_size  = BYTE_GET (esyms[j].st_size);
5673     }
5674
5675  exit_point:
5676   free (shndx);
5677   free (esyms);
5678
5679   if (num_syms_return != NULL)
5680     * num_syms_return = isyms == NULL ? 0 : number;
5681
5682   return isyms;
5683 }
5684
5685 static const char *
5686 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5687 {
5688   static char buff[1024];
5689   char * p = buff;
5690   unsigned int field_size = is_32bit_elf ? 8 : 16;
5691   signed int sindex;
5692   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5693   bfd_vma os_flags = 0;
5694   bfd_vma proc_flags = 0;
5695   bfd_vma unknown_flags = 0;
5696   static const struct
5697     {
5698       const char * str;
5699       unsigned int len;
5700     }
5701   flags [] =
5702     {
5703       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5704       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5705       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5706       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5707       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5708       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5709       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5710       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5711       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5712       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5713       /* IA-64 specific.  */
5714       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5715       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5716       /* IA-64 OpenVMS specific.  */
5717       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5718       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5719       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5720       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5721       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5722       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5723       /* Generic.  */
5724       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5725       /* SPARC specific.  */
5726       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5727       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5728       /* ARM specific.  */
5729       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5730       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5731       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5732       /* GNU specific.  */
5733       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5734       /* VLE specific.  */
5735       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5736     };
5737
5738   if (do_section_details)
5739     {
5740       sprintf (buff, "[%*.*lx]: ",
5741                field_size, field_size, (unsigned long) sh_flags);
5742       p += field_size + 4;
5743     }
5744
5745   while (sh_flags)
5746     {
5747       bfd_vma flag;
5748
5749       flag = sh_flags & - sh_flags;
5750       sh_flags &= ~ flag;
5751
5752       if (do_section_details)
5753         {
5754           switch (flag)
5755             {
5756             case SHF_WRITE:             sindex = 0; break;
5757             case SHF_ALLOC:             sindex = 1; break;
5758             case SHF_EXECINSTR:         sindex = 2; break;
5759             case SHF_MERGE:             sindex = 3; break;
5760             case SHF_STRINGS:           sindex = 4; break;
5761             case SHF_INFO_LINK:         sindex = 5; break;
5762             case SHF_LINK_ORDER:        sindex = 6; break;
5763             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5764             case SHF_GROUP:             sindex = 8; break;
5765             case SHF_TLS:               sindex = 9; break;
5766             case SHF_EXCLUDE:           sindex = 18; break;
5767             case SHF_COMPRESSED:        sindex = 20; break;
5768             case SHF_GNU_MBIND:         sindex = 24; break;
5769
5770             default:
5771               sindex = -1;
5772               switch (filedata->file_header.e_machine)
5773                 {
5774                 case EM_IA_64:
5775                   if (flag == SHF_IA_64_SHORT)
5776                     sindex = 10;
5777                   else if (flag == SHF_IA_64_NORECOV)
5778                     sindex = 11;
5779 #ifdef BFD64
5780                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5781                     switch (flag)
5782                       {
5783                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5784                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5785                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5786                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5787                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5788                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5789                       default:                        break;
5790                       }
5791 #endif
5792                   break;
5793
5794                 case EM_386:
5795                 case EM_IAMCU:
5796                 case EM_X86_64:
5797                 case EM_L1OM:
5798                 case EM_K1OM:
5799                 case EM_OLD_SPARCV9:
5800                 case EM_SPARC32PLUS:
5801                 case EM_SPARCV9:
5802                 case EM_SPARC:
5803                   if (flag == SHF_ORDERED)
5804                     sindex = 19;
5805                   break;
5806
5807                 case EM_ARM:
5808                   switch (flag)
5809                     {
5810                     case SHF_ENTRYSECT: sindex = 21; break;
5811                     case SHF_ARM_PURECODE: sindex = 22; break;
5812                     case SHF_COMDEF: sindex = 23; break;
5813                     default: break;
5814                     }
5815                   break;
5816                 case EM_PPC:
5817                   if (flag == SHF_PPC_VLE)
5818                     sindex = 25;
5819                   break;
5820
5821                 default:
5822                   break;
5823                 }
5824             }
5825
5826           if (sindex != -1)
5827             {
5828               if (p != buff + field_size + 4)
5829                 {
5830                   if (size < (10 + 2))
5831                     {
5832                       warn (_("Internal error: not enough buffer room for section flag info"));
5833                       return _("<unknown>");
5834                     }
5835                   size -= 2;
5836                   *p++ = ',';
5837                   *p++ = ' ';
5838                 }
5839
5840               size -= flags [sindex].len;
5841               p = stpcpy (p, flags [sindex].str);
5842             }
5843           else if (flag & SHF_MASKOS)
5844             os_flags |= flag;
5845           else if (flag & SHF_MASKPROC)
5846             proc_flags |= flag;
5847           else
5848             unknown_flags |= flag;
5849         }
5850       else
5851         {
5852           switch (flag)
5853             {
5854             case SHF_WRITE:             *p = 'W'; break;
5855             case SHF_ALLOC:             *p = 'A'; break;
5856             case SHF_EXECINSTR:         *p = 'X'; break;
5857             case SHF_MERGE:             *p = 'M'; break;
5858             case SHF_STRINGS:           *p = 'S'; break;
5859             case SHF_INFO_LINK:         *p = 'I'; break;
5860             case SHF_LINK_ORDER:        *p = 'L'; break;
5861             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5862             case SHF_GROUP:             *p = 'G'; break;
5863             case SHF_TLS:               *p = 'T'; break;
5864             case SHF_EXCLUDE:           *p = 'E'; break;
5865             case SHF_COMPRESSED:        *p = 'C'; break;
5866             case SHF_GNU_MBIND:         *p = 'D'; break;
5867
5868             default:
5869               if ((filedata->file_header.e_machine == EM_X86_64
5870                    || filedata->file_header.e_machine == EM_L1OM
5871                    || filedata->file_header.e_machine == EM_K1OM)
5872                   && flag == SHF_X86_64_LARGE)
5873                 *p = 'l';
5874               else if (filedata->file_header.e_machine == EM_ARM
5875                        && flag == SHF_ARM_PURECODE)
5876                   *p = 'y';
5877               else if (filedata->file_header.e_machine == EM_PPC
5878                        && flag == SHF_PPC_VLE)
5879                   *p = 'v';
5880               else if (flag & SHF_MASKOS)
5881                 {
5882                   *p = 'o';
5883                   sh_flags &= ~ SHF_MASKOS;
5884                 }
5885               else if (flag & SHF_MASKPROC)
5886                 {
5887                   *p = 'p';
5888                   sh_flags &= ~ SHF_MASKPROC;
5889                 }
5890               else
5891                 *p = 'x';
5892               break;
5893             }
5894           p++;
5895         }
5896     }
5897
5898   if (do_section_details)
5899     {
5900       if (os_flags)
5901         {
5902           size -= 5 + field_size;
5903           if (p != buff + field_size + 4)
5904             {
5905               if (size < (2 + 1))
5906                 {
5907                   warn (_("Internal error: not enough buffer room for section flag info"));
5908                   return _("<unknown>");
5909                 }
5910               size -= 2;
5911               *p++ = ',';
5912               *p++ = ' ';
5913             }
5914           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5915                    (unsigned long) os_flags);
5916           p += 5 + field_size;
5917         }
5918       if (proc_flags)
5919         {
5920           size -= 7 + field_size;
5921           if (p != buff + field_size + 4)
5922             {
5923               if (size < (2 + 1))
5924                 {
5925                   warn (_("Internal error: not enough buffer room for section flag info"));
5926                   return _("<unknown>");
5927                 }
5928               size -= 2;
5929               *p++ = ',';
5930               *p++ = ' ';
5931             }
5932           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5933                    (unsigned long) proc_flags);
5934           p += 7 + field_size;
5935         }
5936       if (unknown_flags)
5937         {
5938           size -= 10 + field_size;
5939           if (p != buff + field_size + 4)
5940             {
5941               if (size < (2 + 1))
5942                 {
5943                   warn (_("Internal error: not enough buffer room for section flag info"));
5944                   return _("<unknown>");
5945                 }
5946               size -= 2;
5947               *p++ = ',';
5948               *p++ = ' ';
5949             }
5950           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5951                    (unsigned long) unknown_flags);
5952           p += 10 + field_size;
5953         }
5954     }
5955
5956   *p = '\0';
5957   return buff;
5958 }
5959
5960 static unsigned int
5961 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5962 {
5963   if (is_32bit_elf)
5964     {
5965       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5966
5967       if (size < sizeof (* echdr))
5968         {
5969           error (_("Compressed section is too small even for a compression header\n"));
5970           return 0;
5971         }
5972
5973       chdr->ch_type = BYTE_GET (echdr->ch_type);
5974       chdr->ch_size = BYTE_GET (echdr->ch_size);
5975       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5976       return sizeof (*echdr);
5977     }
5978   else
5979     {
5980       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5981
5982       if (size < sizeof (* echdr))
5983         {
5984           error (_("Compressed section is too small even for a compression header\n"));
5985           return 0;
5986         }
5987
5988       chdr->ch_type = BYTE_GET (echdr->ch_type);
5989       chdr->ch_size = BYTE_GET (echdr->ch_size);
5990       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5991       return sizeof (*echdr);
5992     }
5993 }
5994
5995 static bfd_boolean
5996 process_section_headers (Filedata * filedata)
5997 {
5998   Elf_Internal_Shdr * section;
5999   unsigned int i;
6000
6001   filedata->section_headers = NULL;
6002
6003   if (filedata->file_header.e_shnum == 0)
6004     {
6005       /* PR binutils/12467.  */
6006       if (filedata->file_header.e_shoff != 0)
6007         {
6008           warn (_("possibly corrupt ELF file header - it has a non-zero"
6009                   " section header offset, but no section headers\n"));
6010           return FALSE;
6011         }
6012       else if (do_sections)
6013         printf (_("\nThere are no sections in this file.\n"));
6014
6015       return TRUE;
6016     }
6017
6018   if (do_sections && !do_header)
6019     printf (ngettext ("There is %d section header, "
6020                       "starting at offset 0x%lx:\n",
6021                       "There are %d section headers, "
6022                       "starting at offset 0x%lx:\n",
6023                       filedata->file_header.e_shnum),
6024             filedata->file_header.e_shnum,
6025             (unsigned long) filedata->file_header.e_shoff);
6026
6027   if (is_32bit_elf)
6028     {
6029       if (! get_32bit_section_headers (filedata, FALSE))
6030         return FALSE;
6031     }
6032   else
6033     {
6034       if (! get_64bit_section_headers (filedata, FALSE))
6035         return FALSE;
6036     }
6037
6038   /* Read in the string table, so that we have names to display.  */
6039   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6040        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6041     {
6042       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6043
6044       if (section->sh_size != 0)
6045         {
6046           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6047                                                       1, section->sh_size,
6048                                                       _("string table"));
6049
6050           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6051         }
6052     }
6053
6054   /* Scan the sections for the dynamic symbol table
6055      and dynamic string table and debug sections.  */
6056   dynamic_symbols = NULL;
6057   dynamic_strings = NULL;
6058   dynamic_syminfo = NULL;
6059   symtab_shndx_list = NULL;
6060
6061   eh_addr_size = is_32bit_elf ? 4 : 8;
6062   switch (filedata->file_header.e_machine)
6063     {
6064     case EM_MIPS:
6065     case EM_MIPS_RS3_LE:
6066       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6067          FDE addresses.  However, the ABI also has a semi-official ILP32
6068          variant for which the normal FDE address size rules apply.
6069
6070          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6071          section, where XX is the size of longs in bits.  Unfortunately,
6072          earlier compilers provided no way of distinguishing ILP32 objects
6073          from LP64 objects, so if there's any doubt, we should assume that
6074          the official LP64 form is being used.  */
6075       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6076           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6077         eh_addr_size = 8;
6078       break;
6079
6080     case EM_H8_300:
6081     case EM_H8_300H:
6082       switch (filedata->file_header.e_flags & EF_H8_MACH)
6083         {
6084         case E_H8_MACH_H8300:
6085         case E_H8_MACH_H8300HN:
6086         case E_H8_MACH_H8300SN:
6087         case E_H8_MACH_H8300SXN:
6088           eh_addr_size = 2;
6089           break;
6090         case E_H8_MACH_H8300H:
6091         case E_H8_MACH_H8300S:
6092         case E_H8_MACH_H8300SX:
6093           eh_addr_size = 4;
6094           break;
6095         }
6096       break;
6097
6098     case EM_M32C_OLD:
6099     case EM_M32C:
6100       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6101         {
6102         case EF_M32C_CPU_M16C:
6103           eh_addr_size = 2;
6104           break;
6105         }
6106       break;
6107     }
6108
6109 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6110   do                                                                    \
6111     {                                                                   \
6112       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6113       if (section->sh_entsize != expected_entsize)                      \
6114         {                                                               \
6115           char buf[40];                                                 \
6116           sprintf_vma (buf, section->sh_entsize);                       \
6117           /* Note: coded this way so that there is a single string for  \
6118              translation.  */ \
6119           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6120           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6121                    (unsigned) expected_entsize);                        \
6122           section->sh_entsize = expected_entsize;                       \
6123         }                                                               \
6124     }                                                                   \
6125   while (0)
6126
6127 #define CHECK_ENTSIZE(section, i, type)                                 \
6128   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6129                         sizeof (Elf64_External_##type))
6130
6131   for (i = 0, section = filedata->section_headers;
6132        i < filedata->file_header.e_shnum;
6133        i++, section++)
6134     {
6135       char * name = SECTION_NAME (section);
6136
6137       if (section->sh_type == SHT_DYNSYM)
6138         {
6139           if (dynamic_symbols != NULL)
6140             {
6141               error (_("File contains multiple dynamic symbol tables\n"));
6142               continue;
6143             }
6144
6145           CHECK_ENTSIZE (section, i, Sym);
6146           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6147         }
6148       else if (section->sh_type == SHT_STRTAB
6149                && streq (name, ".dynstr"))
6150         {
6151           if (dynamic_strings != NULL)
6152             {
6153               error (_("File contains multiple dynamic string tables\n"));
6154               continue;
6155             }
6156
6157           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6158                                                1, section->sh_size,
6159                                                _("dynamic strings"));
6160           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6161         }
6162       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6163         {
6164           elf_section_list * entry = xmalloc (sizeof * entry);
6165
6166           entry->hdr = section;
6167           entry->next = symtab_shndx_list;
6168           symtab_shndx_list = entry;
6169         }
6170       else if (section->sh_type == SHT_SYMTAB)
6171         CHECK_ENTSIZE (section, i, Sym);
6172       else if (section->sh_type == SHT_GROUP)
6173         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6174       else if (section->sh_type == SHT_REL)
6175         CHECK_ENTSIZE (section, i, Rel);
6176       else if (section->sh_type == SHT_RELA)
6177         CHECK_ENTSIZE (section, i, Rela);
6178       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6179                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6180                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6181                 || do_debug_str || do_debug_loc || do_debug_ranges
6182                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6183                && (const_strneq (name, ".debug_")
6184                    || const_strneq (name, ".zdebug_")))
6185         {
6186           if (name[1] == 'z')
6187             name += sizeof (".zdebug_") - 1;
6188           else
6189             name += sizeof (".debug_") - 1;
6190
6191           if (do_debugging
6192               || (do_debug_info     && const_strneq (name, "info"))
6193               || (do_debug_info     && const_strneq (name, "types"))
6194               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6195               || (do_debug_lines    && strcmp (name, "line") == 0)
6196               || (do_debug_lines    && const_strneq (name, "line."))
6197               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6198               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6199               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6200               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6201               || (do_debug_aranges  && const_strneq (name, "aranges"))
6202               || (do_debug_ranges   && const_strneq (name, "ranges"))
6203               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6204               || (do_debug_frames   && const_strneq (name, "frame"))
6205               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6206               || (do_debug_macinfo  && const_strneq (name, "macro"))
6207               || (do_debug_str      && const_strneq (name, "str"))
6208               || (do_debug_loc      && const_strneq (name, "loc"))
6209               || (do_debug_loc      && const_strneq (name, "loclists"))
6210               || (do_debug_addr     && const_strneq (name, "addr"))
6211               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6212               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6213               )
6214             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6215         }
6216       /* Linkonce section to be combined with .debug_info at link time.  */
6217       else if ((do_debugging || do_debug_info)
6218                && const_strneq (name, ".gnu.linkonce.wi."))
6219         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220       else if (do_debug_frames && streq (name, ".eh_frame"))
6221         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6222       else if (do_gdb_index && (streq (name, ".gdb_index")
6223                                 || streq (name, ".debug_names")))
6224         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6225       /* Trace sections for Itanium VMS.  */
6226       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6227                 || do_trace_aranges)
6228                && const_strneq (name, ".trace_"))
6229         {
6230           name += sizeof (".trace_") - 1;
6231
6232           if (do_debugging
6233               || (do_trace_info     && streq (name, "info"))
6234               || (do_trace_abbrevs  && streq (name, "abbrev"))
6235               || (do_trace_aranges  && streq (name, "aranges"))
6236               )
6237             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6238         }
6239       else if ((do_debugging || do_debug_links)
6240                && (const_strneq (name, ".gnu_debuglink")
6241                    || const_strneq (name, ".gnu_debugaltlink")))
6242         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6243     }
6244
6245   if (! do_sections)
6246     return TRUE;
6247
6248   if (filedata->file_header.e_shnum > 1)
6249     printf (_("\nSection Headers:\n"));
6250   else
6251     printf (_("\nSection Header:\n"));
6252
6253   if (is_32bit_elf)
6254     {
6255       if (do_section_details)
6256         {
6257           printf (_("  [Nr] Name\n"));
6258           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6259         }
6260       else
6261         printf
6262           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6263     }
6264   else if (do_wide)
6265     {
6266       if (do_section_details)
6267         {
6268           printf (_("  [Nr] Name\n"));
6269           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6270         }
6271       else
6272         printf
6273           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6274     }
6275   else
6276     {
6277       if (do_section_details)
6278         {
6279           printf (_("  [Nr] Name\n"));
6280           printf (_("       Type              Address          Offset            Link\n"));
6281           printf (_("       Size              EntSize          Info              Align\n"));
6282         }
6283       else
6284         {
6285           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6286           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6287         }
6288     }
6289
6290   if (do_section_details)
6291     printf (_("       Flags\n"));
6292
6293   for (i = 0, section = filedata->section_headers;
6294        i < filedata->file_header.e_shnum;
6295        i++, section++)
6296     {
6297       /* Run some sanity checks on the section header.  */
6298
6299       /* Check the sh_link field.  */
6300       switch (section->sh_type)
6301         {
6302         case SHT_SYMTAB_SHNDX:
6303         case SHT_GROUP:
6304         case SHT_HASH:
6305         case SHT_GNU_HASH:
6306         case SHT_GNU_versym:
6307         case SHT_REL:
6308         case SHT_RELA:
6309           if (section->sh_link < 1
6310               || section->sh_link >= filedata->file_header.e_shnum
6311               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6312                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6313             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6314                   i, section->sh_link);
6315           break;
6316
6317         case SHT_DYNAMIC:
6318         case SHT_SYMTAB:
6319         case SHT_DYNSYM:
6320         case SHT_GNU_verneed:
6321         case SHT_GNU_verdef:
6322         case SHT_GNU_LIBLIST:
6323           if (section->sh_link < 1
6324               || section->sh_link >= filedata->file_header.e_shnum
6325               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6326             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6327                   i, section->sh_link);
6328           break;
6329
6330         case SHT_INIT_ARRAY:
6331         case SHT_FINI_ARRAY:
6332         case SHT_PREINIT_ARRAY:
6333           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6334             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6335                   i, section->sh_link);
6336           break;
6337
6338         default:
6339           /* FIXME: Add support for target specific section types.  */
6340 #if 0     /* Currently we do not check other section types as there are too
6341              many special cases.  Stab sections for example have a type
6342              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6343              section.  */
6344           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6345             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6346                   i, section->sh_link);
6347 #endif
6348           break;
6349         }
6350
6351       /* Check the sh_info field.  */
6352       switch (section->sh_type)
6353         {
6354         case SHT_REL:
6355         case SHT_RELA:
6356           if (section->sh_info < 1
6357               || section->sh_info >= filedata->file_header.e_shnum
6358               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6359                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6360                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6361                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6362                   /* FIXME: Are other section types valid ?  */
6363                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6364             {
6365               if (section->sh_info == 0
6366                   && (filedata->file_header.e_type == ET_EXEC
6367                       || filedata->file_header.e_type == ET_DYN
6368                       /* These next two tests may be redundant, but
6369                          they have been left in for paranoia's sake.  */
6370                       || streq (SECTION_NAME (section), ".rel.dyn")
6371                       || streq (SECTION_NAME (section), ".rela.dyn")))
6372                 /* Dynamic relocations apply to segments, not sections, so
6373                    they do not need an sh_info value.  */
6374                 ;
6375               else
6376                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6377                       i, section->sh_info);
6378             }
6379           break;
6380
6381         case SHT_DYNAMIC:
6382         case SHT_HASH:
6383         case SHT_SYMTAB_SHNDX:
6384         case SHT_INIT_ARRAY:
6385         case SHT_FINI_ARRAY:
6386         case SHT_PREINIT_ARRAY:
6387           if (section->sh_info != 0)
6388             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6389                   i, section->sh_info);
6390           break;
6391
6392         case SHT_GROUP:
6393         case SHT_SYMTAB:
6394         case SHT_DYNSYM:
6395           /* A symbol index - we assume that it is valid.  */
6396           break;
6397
6398         default:
6399           /* FIXME: Add support for target specific section types.  */
6400           if (section->sh_type == SHT_NOBITS)
6401             /* NOBITS section headers with non-zero sh_info fields can be
6402                created when a binary is stripped of everything but its debug
6403                information.  The stripped sections have their headers
6404                preserved but their types set to SHT_NOBITS.  So do not check
6405                this type of section.  */
6406             ;
6407           else if (section->sh_flags & SHF_INFO_LINK)
6408             {
6409               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6410                 warn (_("[%2u]: Expected link to another section in info field"), i);
6411             }
6412           else if (section->sh_type < SHT_LOOS
6413                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6414                    && section->sh_info != 0)
6415             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6416                   i, section->sh_info);
6417           break;
6418         }
6419
6420       /* Check the sh_size field.  */
6421       if (section->sh_size > filedata->file_size
6422           && section->sh_type != SHT_NOBITS
6423           && section->sh_type != SHT_NULL
6424           && section->sh_type < SHT_LOOS)
6425         warn (_("Size of section %u is larger than the entire file!\n"), i);
6426
6427       printf ("  [%2u] ", i);
6428       if (do_section_details)
6429         printf ("%s\n      ", printable_section_name (filedata, section));
6430       else
6431         print_symbol (-17, SECTION_NAME (section));
6432
6433       printf (do_wide ? " %-15s " : " %-15.15s ",
6434               get_section_type_name (filedata, section->sh_type));
6435
6436       if (is_32bit_elf)
6437         {
6438           const char * link_too_big = NULL;
6439
6440           print_vma (section->sh_addr, LONG_HEX);
6441
6442           printf ( " %6.6lx %6.6lx %2.2lx",
6443                    (unsigned long) section->sh_offset,
6444                    (unsigned long) section->sh_size,
6445                    (unsigned long) section->sh_entsize);
6446
6447           if (do_section_details)
6448             fputs ("  ", stdout);
6449           else
6450             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6451
6452           if (section->sh_link >= filedata->file_header.e_shnum)
6453             {
6454               link_too_big = "";
6455               /* The sh_link value is out of range.  Normally this indicates
6456                  an error but it can have special values in Solaris binaries.  */
6457               switch (filedata->file_header.e_machine)
6458                 {
6459                 case EM_386:
6460                 case EM_IAMCU:
6461                 case EM_X86_64:
6462                 case EM_L1OM:
6463                 case EM_K1OM:
6464                 case EM_OLD_SPARCV9:
6465                 case EM_SPARC32PLUS:
6466                 case EM_SPARCV9:
6467                 case EM_SPARC:
6468                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6469                     link_too_big = "BEFORE";
6470                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6471                     link_too_big = "AFTER";
6472                   break;
6473                 default:
6474                   break;
6475                 }
6476             }
6477
6478           if (do_section_details)
6479             {
6480               if (link_too_big != NULL && * link_too_big)
6481                 printf ("<%s> ", link_too_big);
6482               else
6483                 printf ("%2u ", section->sh_link);
6484               printf ("%3u %2lu\n", section->sh_info,
6485                       (unsigned long) section->sh_addralign);
6486             }
6487           else
6488             printf ("%2u %3u %2lu\n",
6489                     section->sh_link,
6490                     section->sh_info,
6491                     (unsigned long) section->sh_addralign);
6492
6493           if (link_too_big && ! * link_too_big)
6494             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6495                   i, section->sh_link);
6496         }
6497       else if (do_wide)
6498         {
6499           print_vma (section->sh_addr, LONG_HEX);
6500
6501           if ((long) section->sh_offset == section->sh_offset)
6502             printf (" %6.6lx", (unsigned long) section->sh_offset);
6503           else
6504             {
6505               putchar (' ');
6506               print_vma (section->sh_offset, LONG_HEX);
6507             }
6508
6509           if ((unsigned long) section->sh_size == section->sh_size)
6510             printf (" %6.6lx", (unsigned long) section->sh_size);
6511           else
6512             {
6513               putchar (' ');
6514               print_vma (section->sh_size, LONG_HEX);
6515             }
6516
6517           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6518             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6519           else
6520             {
6521               putchar (' ');
6522               print_vma (section->sh_entsize, LONG_HEX);
6523             }
6524
6525           if (do_section_details)
6526             fputs ("  ", stdout);
6527           else
6528             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6529
6530           printf ("%2u %3u ", section->sh_link, section->sh_info);
6531
6532           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6533             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6534           else
6535             {
6536               print_vma (section->sh_addralign, DEC);
6537               putchar ('\n');
6538             }
6539         }
6540       else if (do_section_details)
6541         {
6542           putchar (' ');
6543           print_vma (section->sh_addr, LONG_HEX);
6544           if ((long) section->sh_offset == section->sh_offset)
6545             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6546           else
6547             {
6548               printf ("  ");
6549               print_vma (section->sh_offset, LONG_HEX);
6550             }
6551           printf ("  %u\n       ", section->sh_link);
6552           print_vma (section->sh_size, LONG_HEX);
6553           putchar (' ');
6554           print_vma (section->sh_entsize, LONG_HEX);
6555
6556           printf ("  %-16u  %lu\n",
6557                   section->sh_info,
6558                   (unsigned long) section->sh_addralign);
6559         }
6560       else
6561         {
6562           putchar (' ');
6563           print_vma (section->sh_addr, LONG_HEX);
6564           if ((long) section->sh_offset == section->sh_offset)
6565             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6566           else
6567             {
6568               printf ("  ");
6569               print_vma (section->sh_offset, LONG_HEX);
6570             }
6571           printf ("\n       ");
6572           print_vma (section->sh_size, LONG_HEX);
6573           printf ("  ");
6574           print_vma (section->sh_entsize, LONG_HEX);
6575
6576           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6577
6578           printf ("     %2u   %3u     %lu\n",
6579                   section->sh_link,
6580                   section->sh_info,
6581                   (unsigned long) section->sh_addralign);
6582         }
6583
6584       if (do_section_details)
6585         {
6586           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6587           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6588             {
6589               /* Minimum section size is 12 bytes for 32-bit compression
6590                  header + 12 bytes for compressed data header.  */
6591               unsigned char buf[24];
6592
6593               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6594               if (get_data (&buf, filedata, section->sh_offset, 1,
6595                             sizeof (buf), _("compression header")))
6596                 {
6597                   Elf_Internal_Chdr chdr;
6598
6599                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6600
6601                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6602                     printf ("       ZLIB, ");
6603                   else
6604                     printf (_("       [<unknown>: 0x%x], "),
6605                             chdr.ch_type);
6606                   print_vma (chdr.ch_size, LONG_HEX);
6607                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6608                 }
6609             }
6610         }
6611     }
6612
6613   if (!do_section_details)
6614     {
6615       /* The ordering of the letters shown here matches the ordering of the
6616          corresponding SHF_xxx values, and hence the order in which these
6617          letters will be displayed to the user.  */
6618       printf (_("Key to Flags:\n\
6619   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6620   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6621   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6622       if (filedata->file_header.e_machine == EM_X86_64
6623           || filedata->file_header.e_machine == EM_L1OM
6624           || filedata->file_header.e_machine == EM_K1OM)
6625         printf (_("l (large), "));
6626       else if (filedata->file_header.e_machine == EM_ARM)
6627         printf (_("y (purecode), "));
6628       else if (filedata->file_header.e_machine == EM_PPC)
6629         printf (_("v (VLE), "));
6630       printf ("p (processor specific)\n");
6631     }
6632
6633   return TRUE;
6634 }
6635
6636 static const char *
6637 get_group_flags (unsigned int flags)
6638 {
6639   static char buff[128];
6640
6641   if (flags == 0)
6642     return "";
6643   else if (flags == GRP_COMDAT)
6644     return "COMDAT ";
6645
6646   snprintf (buff, 14, _("[0x%x: "), flags);
6647
6648   flags &= ~ GRP_COMDAT;
6649   if (flags & GRP_MASKOS)
6650     {
6651       strcat (buff, "<OS specific>");
6652       flags &= ~ GRP_MASKOS;
6653     }
6654
6655   if (flags & GRP_MASKPROC)
6656     {
6657       strcat (buff, "<PROC specific>");
6658       flags &= ~ GRP_MASKPROC;
6659     }
6660
6661   if (flags)
6662     strcat (buff, "<unknown>");
6663
6664   strcat (buff, "]");
6665   return buff;
6666 }
6667
6668 static bfd_boolean
6669 process_section_groups (Filedata * filedata)
6670 {
6671   Elf_Internal_Shdr * section;
6672   unsigned int i;
6673   struct group * group;
6674   Elf_Internal_Shdr * symtab_sec;
6675   Elf_Internal_Shdr * strtab_sec;
6676   Elf_Internal_Sym * symtab;
6677   unsigned long num_syms;
6678   char * strtab;
6679   size_t strtab_size;
6680
6681   /* Don't process section groups unless needed.  */
6682   if (!do_unwind && !do_section_groups)
6683     return TRUE;
6684
6685   if (filedata->file_header.e_shnum == 0)
6686     {
6687       if (do_section_groups)
6688         printf (_("\nThere are no sections to group in this file.\n"));
6689
6690       return TRUE;
6691     }
6692
6693   if (filedata->section_headers == NULL)
6694     {
6695       error (_("Section headers are not available!\n"));
6696       /* PR 13622: This can happen with a corrupt ELF header.  */
6697       return FALSE;
6698     }
6699
6700   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6701                                                      sizeof (struct group *));
6702
6703   if (section_headers_groups == NULL)
6704     {
6705       error (_("Out of memory reading %u section group headers\n"),
6706              filedata->file_header.e_shnum);
6707       return FALSE;
6708     }
6709
6710   /* Scan the sections for the group section.  */
6711   group_count = 0;
6712   for (i = 0, section = filedata->section_headers;
6713        i < filedata->file_header.e_shnum;
6714        i++, section++)
6715     if (section->sh_type == SHT_GROUP)
6716       group_count++;
6717
6718   if (group_count == 0)
6719     {
6720       if (do_section_groups)
6721         printf (_("\nThere are no section groups in this file.\n"));
6722
6723       return TRUE;
6724     }
6725
6726   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6727
6728   if (section_groups == NULL)
6729     {
6730       error (_("Out of memory reading %lu groups\n"),
6731              (unsigned long) group_count);
6732       return FALSE;
6733     }
6734
6735   symtab_sec = NULL;
6736   strtab_sec = NULL;
6737   symtab = NULL;
6738   num_syms = 0;
6739   strtab = NULL;
6740   strtab_size = 0;
6741   for (i = 0, section = filedata->section_headers, group = section_groups;
6742        i < filedata->file_header.e_shnum;
6743        i++, section++)
6744     {
6745       if (section->sh_type == SHT_GROUP)
6746         {
6747           const char * name = printable_section_name (filedata, section);
6748           const char * group_name;
6749           unsigned char * start;
6750           unsigned char * indices;
6751           unsigned int entry, j, size;
6752           Elf_Internal_Shdr * sec;
6753           Elf_Internal_Sym * sym;
6754
6755           /* Get the symbol table.  */
6756           if (section->sh_link >= filedata->file_header.e_shnum
6757               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6758                   != SHT_SYMTAB))
6759             {
6760               error (_("Bad sh_link in group section `%s'\n"), name);
6761               continue;
6762             }
6763
6764           if (symtab_sec != sec)
6765             {
6766               symtab_sec = sec;
6767               if (symtab)
6768                 free (symtab);
6769               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6770             }
6771
6772           if (symtab == NULL)
6773             {
6774               error (_("Corrupt header in group section `%s'\n"), name);
6775               continue;
6776             }
6777
6778           if (section->sh_info >= num_syms)
6779             {
6780               error (_("Bad sh_info in group section `%s'\n"), name);
6781               continue;
6782             }
6783
6784           sym = symtab + section->sh_info;
6785
6786           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6787             {
6788               if (sym->st_shndx == 0
6789                   || sym->st_shndx >= filedata->file_header.e_shnum)
6790                 {
6791                   error (_("Bad sh_info in group section `%s'\n"), name);
6792                   continue;
6793                 }
6794
6795               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6796               strtab_sec = NULL;
6797               if (strtab)
6798                 free (strtab);
6799               strtab = NULL;
6800               strtab_size = 0;
6801             }
6802           else
6803             {
6804               /* Get the string table.  */
6805               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6806                 {
6807                   strtab_sec = NULL;
6808                   if (strtab)
6809                     free (strtab);
6810                   strtab = NULL;
6811                   strtab_size = 0;
6812                 }
6813               else if (strtab_sec
6814                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6815                 {
6816                   strtab_sec = sec;
6817                   if (strtab)
6818                     free (strtab);
6819
6820                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6821                                               1, strtab_sec->sh_size,
6822                                               _("string table"));
6823                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6824                 }
6825               group_name = sym->st_name < strtab_size
6826                 ? strtab + sym->st_name : _("<corrupt>");
6827             }
6828
6829           /* PR 17531: file: loop.  */
6830           if (section->sh_entsize > section->sh_size)
6831             {
6832               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6833                      printable_section_name (filedata, section),
6834                      (unsigned long) section->sh_entsize,
6835                      (unsigned long) section->sh_size);
6836               break;
6837             }
6838
6839           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6840                                               1, section->sh_size,
6841                                               _("section data"));
6842           if (start == NULL)
6843             continue;
6844
6845           indices = start;
6846           size = (section->sh_size / section->sh_entsize) - 1;
6847           entry = byte_get (indices, 4);
6848           indices += 4;
6849
6850           if (do_section_groups)
6851             {
6852               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6853                       get_group_flags (entry), i, name, group_name, size);
6854
6855               printf (_("   [Index]    Name\n"));
6856             }
6857
6858           group->group_index = i;
6859
6860           for (j = 0; j < size; j++)
6861             {
6862               struct group_list * g;
6863
6864               entry = byte_get (indices, 4);
6865               indices += 4;
6866
6867               if (entry >= filedata->file_header.e_shnum)
6868                 {
6869                   static unsigned num_group_errors = 0;
6870
6871                   if (num_group_errors ++ < 10)
6872                     {
6873                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6874                              entry, i, filedata->file_header.e_shnum - 1);
6875                       if (num_group_errors == 10)
6876                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6877                     }
6878                   continue;
6879                 }
6880
6881               if (section_headers_groups [entry] != NULL)
6882                 {
6883                   if (entry)
6884                     {
6885                       static unsigned num_errs = 0;
6886
6887                       if (num_errs ++ < 10)
6888                         {
6889                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6890                                  entry, i,
6891                                  section_headers_groups [entry]->group_index);
6892                           if (num_errs == 10)
6893                             warn (_("Further error messages about already contained group sections suppressed\n"));
6894                         }
6895                       continue;
6896                     }
6897                   else
6898                     {
6899                       /* Intel C/C++ compiler may put section 0 in a
6900                          section group.  We just warn it the first time
6901                          and ignore it afterwards.  */
6902                       static bfd_boolean warned = FALSE;
6903                       if (!warned)
6904                         {
6905                           error (_("section 0 in group section [%5u]\n"),
6906                                  section_headers_groups [entry]->group_index);
6907                           warned = TRUE;
6908                         }
6909                     }
6910                 }
6911
6912               section_headers_groups [entry] = group;
6913
6914               if (do_section_groups)
6915                 {
6916                   sec = filedata->section_headers + entry;
6917                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6918                 }
6919
6920               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6921               g->section_index = entry;
6922               g->next = group->root;
6923               group->root = g;
6924             }
6925
6926           if (start)
6927             free (start);
6928
6929           group++;
6930         }
6931     }
6932
6933   if (symtab)
6934     free (symtab);
6935   if (strtab)
6936     free (strtab);
6937   return TRUE;
6938 }
6939
6940 /* Data used to display dynamic fixups.  */
6941
6942 struct ia64_vms_dynfixup
6943 {
6944   bfd_vma needed_ident;         /* Library ident number.  */
6945   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6946   bfd_vma fixup_needed;         /* Index of the library.  */
6947   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6948   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6949 };
6950
6951 /* Data used to display dynamic relocations.  */
6952
6953 struct ia64_vms_dynimgrela
6954 {
6955   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6956   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6957 };
6958
6959 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6960    library).  */
6961
6962 static bfd_boolean
6963 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6964                               struct ia64_vms_dynfixup *  fixup,
6965                               const char *                strtab,
6966                               unsigned int                strtab_sz)
6967 {
6968   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6969   long i;
6970   const char * lib_name;
6971
6972   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6973                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6974                    _("dynamic section image fixups"));
6975   if (!imfs)
6976     return FALSE;
6977
6978   if (fixup->needed < strtab_sz)
6979     lib_name = strtab + fixup->needed;
6980   else
6981     {
6982       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6983             (unsigned long) fixup->needed);
6984       lib_name = "???";
6985     }
6986   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6987           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6988   printf
6989     (_("Seg Offset           Type                             SymVec DataType\n"));
6990
6991   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6992     {
6993       unsigned int type;
6994       const char *rtype;
6995
6996       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6997       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6998       type = BYTE_GET (imfs [i].type);
6999       rtype = elf_ia64_reloc_type (type);
7000       if (rtype == NULL)
7001         printf (" 0x%08x                       ", type);
7002       else
7003         printf (" %-32s ", rtype);
7004       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7005       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7006     }
7007
7008   free (imfs);
7009   return TRUE;
7010 }
7011
7012 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7013
7014 static bfd_boolean
7015 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7016 {
7017   Elf64_External_VMS_IMAGE_RELA *imrs;
7018   long i;
7019
7020   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7021                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7022                    _("dynamic section image relocations"));
7023   if (!imrs)
7024     return FALSE;
7025
7026   printf (_("\nImage relocs\n"));
7027   printf
7028     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7029
7030   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7031     {
7032       unsigned int type;
7033       const char *rtype;
7034
7035       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7036       printf ("%08" BFD_VMA_FMT "x ",
7037               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7038       type = BYTE_GET (imrs [i].type);
7039       rtype = elf_ia64_reloc_type (type);
7040       if (rtype == NULL)
7041         printf ("0x%08x                      ", type);
7042       else
7043         printf ("%-31s ", rtype);
7044       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7045       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7046       printf ("%08" BFD_VMA_FMT "x\n",
7047               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7048     }
7049
7050   free (imrs);
7051   return TRUE;
7052 }
7053
7054 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7055
7056 static bfd_boolean
7057 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7058 {
7059   struct ia64_vms_dynfixup fixup;
7060   struct ia64_vms_dynimgrela imgrela;
7061   Elf_Internal_Dyn *entry;
7062   bfd_vma strtab_off = 0;
7063   bfd_vma strtab_sz = 0;
7064   char *strtab = NULL;
7065   bfd_boolean res = TRUE;
7066
7067   memset (&fixup, 0, sizeof (fixup));
7068   memset (&imgrela, 0, sizeof (imgrela));
7069
7070   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7071   for (entry = dynamic_section;
7072        entry < dynamic_section + dynamic_nent;
7073        entry++)
7074     {
7075       switch (entry->d_tag)
7076         {
7077         case DT_IA_64_VMS_STRTAB_OFFSET:
7078           strtab_off = entry->d_un.d_val;
7079           break;
7080         case DT_STRSZ:
7081           strtab_sz = entry->d_un.d_val;
7082           if (strtab == NULL)
7083             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7084                                1, strtab_sz, _("dynamic string section"));
7085           break;
7086
7087         case DT_IA_64_VMS_NEEDED_IDENT:
7088           fixup.needed_ident = entry->d_un.d_val;
7089           break;
7090         case DT_NEEDED:
7091           fixup.needed = entry->d_un.d_val;
7092           break;
7093         case DT_IA_64_VMS_FIXUP_NEEDED:
7094           fixup.fixup_needed = entry->d_un.d_val;
7095           break;
7096         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7097           fixup.fixup_rela_cnt = entry->d_un.d_val;
7098           break;
7099         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7100           fixup.fixup_rela_off = entry->d_un.d_val;
7101           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7102             res = FALSE;
7103           break;
7104         case DT_IA_64_VMS_IMG_RELA_CNT:
7105           imgrela.img_rela_cnt = entry->d_un.d_val;
7106           break;
7107         case DT_IA_64_VMS_IMG_RELA_OFF:
7108           imgrela.img_rela_off = entry->d_un.d_val;
7109           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7110             res = FALSE;
7111           break;
7112
7113         default:
7114           break;
7115         }
7116     }
7117
7118   if (strtab != NULL)
7119     free (strtab);
7120
7121   return res;
7122 }
7123
7124 static struct
7125 {
7126   const char * name;
7127   int reloc;
7128   int size;
7129   int rela;
7130 }
7131   dynamic_relocations [] =
7132 {
7133   { "REL", DT_REL, DT_RELSZ, FALSE },
7134   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7135   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7136 };
7137
7138 /* Process the reloc section.  */
7139
7140 static bfd_boolean
7141 process_relocs (Filedata * filedata)
7142 {
7143   unsigned long rel_size;
7144   unsigned long rel_offset;
7145
7146   if (!do_reloc)
7147     return TRUE;
7148
7149   if (do_using_dynamic)
7150     {
7151       int          is_rela;
7152       const char * name;
7153       bfd_boolean  has_dynamic_reloc;
7154       unsigned int i;
7155
7156       has_dynamic_reloc = FALSE;
7157
7158       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7159         {
7160           is_rela = dynamic_relocations [i].rela;
7161           name = dynamic_relocations [i].name;
7162           rel_size = dynamic_info [dynamic_relocations [i].size];
7163           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7164
7165           if (rel_size)
7166             has_dynamic_reloc = TRUE;
7167
7168           if (is_rela == UNKNOWN)
7169             {
7170               if (dynamic_relocations [i].reloc == DT_JMPREL)
7171                 switch (dynamic_info[DT_PLTREL])
7172                   {
7173                   case DT_REL:
7174                     is_rela = FALSE;
7175                     break;
7176                   case DT_RELA:
7177                     is_rela = TRUE;
7178                     break;
7179                   }
7180             }
7181
7182           if (rel_size)
7183             {
7184               printf
7185                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7186                  name, rel_offset, rel_size);
7187
7188               dump_relocations (filedata,
7189                                 offset_from_vma (filedata, rel_offset, rel_size),
7190                                 rel_size,
7191                                 dynamic_symbols, num_dynamic_syms,
7192                                 dynamic_strings, dynamic_strings_length,
7193                                 is_rela, TRUE /* is_dynamic */);
7194             }
7195         }
7196
7197       if (is_ia64_vms (filedata))
7198         if (process_ia64_vms_dynamic_relocs (filedata))
7199           has_dynamic_reloc = TRUE;
7200
7201       if (! has_dynamic_reloc)
7202         printf (_("\nThere are no dynamic relocations in this file.\n"));
7203     }
7204   else
7205     {
7206       Elf_Internal_Shdr * section;
7207       unsigned long i;
7208       bfd_boolean found = FALSE;
7209
7210       for (i = 0, section = filedata->section_headers;
7211            i < filedata->file_header.e_shnum;
7212            i++, section++)
7213         {
7214           if (   section->sh_type != SHT_RELA
7215               && section->sh_type != SHT_REL)
7216             continue;
7217
7218           rel_offset = section->sh_offset;
7219           rel_size   = section->sh_size;
7220
7221           if (rel_size)
7222             {
7223               Elf_Internal_Shdr * strsec;
7224               int is_rela;
7225               unsigned long num_rela;
7226
7227               printf (_("\nRelocation section "));
7228
7229               if (filedata->string_table == NULL)
7230                 printf ("%d", section->sh_name);
7231               else
7232                 printf ("'%s'", printable_section_name (filedata, section));
7233
7234               num_rela = rel_size / section->sh_entsize;
7235               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7236                                 " at offset 0x%lx contains %lu entries:\n",
7237                                 num_rela),
7238                       rel_offset, num_rela);
7239
7240               is_rela = section->sh_type == SHT_RELA;
7241
7242               if (section->sh_link != 0
7243                   && section->sh_link < filedata->file_header.e_shnum)
7244                 {
7245                   Elf_Internal_Shdr * symsec;
7246                   Elf_Internal_Sym *  symtab;
7247                   unsigned long nsyms;
7248                   unsigned long strtablen = 0;
7249                   char * strtab = NULL;
7250
7251                   symsec = filedata->section_headers + section->sh_link;
7252                   if (symsec->sh_type != SHT_SYMTAB
7253                       && symsec->sh_type != SHT_DYNSYM)
7254                     continue;
7255
7256                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7257
7258                   if (symtab == NULL)
7259                     continue;
7260
7261                   if (symsec->sh_link != 0
7262                       && symsec->sh_link < filedata->file_header.e_shnum)
7263                     {
7264                       strsec = filedata->section_headers + symsec->sh_link;
7265
7266                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7267                                                   1, strsec->sh_size,
7268                                                   _("string table"));
7269                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7270                     }
7271
7272                   dump_relocations (filedata, rel_offset, rel_size,
7273                                     symtab, nsyms, strtab, strtablen,
7274                                     is_rela,
7275                                     symsec->sh_type == SHT_DYNSYM);
7276                   if (strtab)
7277                     free (strtab);
7278                   free (symtab);
7279                 }
7280               else
7281                 dump_relocations (filedata, rel_offset, rel_size,
7282                                   NULL, 0, NULL, 0, is_rela,
7283                                   FALSE /* is_dynamic */);
7284
7285               found = TRUE;
7286             }
7287         }
7288
7289       if (! found)
7290         {
7291           /* Users sometimes forget the -D option, so try to be helpful.  */
7292           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7293             {
7294               if (dynamic_info [dynamic_relocations [i].size])
7295                 {
7296                   printf (_("\nThere are no static relocations in this file."));
7297                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7298
7299                   break;
7300                 }
7301             }
7302           if (i == ARRAY_SIZE (dynamic_relocations))
7303             printf (_("\nThere are no relocations in this file.\n"));
7304         }
7305     }
7306
7307   return TRUE;
7308 }
7309
7310 /* An absolute address consists of a section and an offset.  If the
7311    section is NULL, the offset itself is the address, otherwise, the
7312    address equals to LOAD_ADDRESS(section) + offset.  */
7313
7314 struct absaddr
7315 {
7316   unsigned short section;
7317   bfd_vma offset;
7318 };
7319
7320 #define ABSADDR(a) \
7321   ((a).section \
7322    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7323    : (a).offset)
7324
7325 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7326    name, if found, and the offset from the symbol to ADDR.  */
7327
7328 static void
7329 find_symbol_for_address (Filedata *          filedata,
7330                          Elf_Internal_Sym *  symtab,
7331                          unsigned long       nsyms,
7332                          const char *        strtab,
7333                          unsigned long       strtab_size,
7334                          struct absaddr      addr,
7335                          const char **       symname,
7336                          bfd_vma *           offset)
7337 {
7338   bfd_vma dist = 0x100000;
7339   Elf_Internal_Sym * sym;
7340   Elf_Internal_Sym * beg;
7341   Elf_Internal_Sym * end;
7342   Elf_Internal_Sym * best = NULL;
7343
7344   REMOVE_ARCH_BITS (addr.offset);
7345   beg = symtab;
7346   end = symtab + nsyms;
7347
7348   while (beg < end)
7349     {
7350       bfd_vma value;
7351
7352       sym = beg + (end - beg) / 2;
7353
7354       value = sym->st_value;
7355       REMOVE_ARCH_BITS (value);
7356
7357       if (sym->st_name != 0
7358           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7359           && addr.offset >= value
7360           && addr.offset - value < dist)
7361         {
7362           best = sym;
7363           dist = addr.offset - value;
7364           if (!dist)
7365             break;
7366         }
7367
7368       if (addr.offset < value)
7369         end = sym;
7370       else
7371         beg = sym + 1;
7372     }
7373
7374   if (best)
7375     {
7376       *symname = (best->st_name >= strtab_size
7377                   ? _("<corrupt>") : strtab + best->st_name);
7378       *offset = dist;
7379       return;
7380     }
7381
7382   *symname = NULL;
7383   *offset = addr.offset;
7384 }
7385
7386 static /* signed */ int
7387 symcmp (const void *p, const void *q)
7388 {
7389   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7390   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7391
7392   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7393 }
7394
7395 /* Process the unwind section.  */
7396
7397 #include "unwind-ia64.h"
7398
7399 struct ia64_unw_table_entry
7400 {
7401   struct absaddr start;
7402   struct absaddr end;
7403   struct absaddr info;
7404 };
7405
7406 struct ia64_unw_aux_info
7407 {
7408   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7409   unsigned long                 table_len;      /* Length of unwind table.  */
7410   unsigned char *               info;           /* Unwind info.  */
7411   unsigned long                 info_size;      /* Size of unwind info.  */
7412   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7413   bfd_vma                       seg_base;       /* Starting address of segment.  */
7414   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7415   unsigned long                 nsyms;          /* Number of symbols.  */
7416   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7417   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7418   char *                        strtab;         /* The string table.  */
7419   unsigned long                 strtab_size;    /* Size of string table.  */
7420 };
7421
7422 static bfd_boolean
7423 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7424 {
7425   struct ia64_unw_table_entry * tp;
7426   unsigned long j, nfuns;
7427   int in_body;
7428   bfd_boolean res = TRUE;
7429
7430   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7431   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7432     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7433       aux->funtab[nfuns++] = aux->symtab[j];
7434   aux->nfuns = nfuns;
7435   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7436
7437   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7438     {
7439       bfd_vma stamp;
7440       bfd_vma offset;
7441       const unsigned char * dp;
7442       const unsigned char * head;
7443       const unsigned char * end;
7444       const char * procname;
7445
7446       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7447                                aux->strtab_size, tp->start, &procname, &offset);
7448
7449       fputs ("\n<", stdout);
7450
7451       if (procname)
7452         {
7453           fputs (procname, stdout);
7454
7455           if (offset)
7456             printf ("+%lx", (unsigned long) offset);
7457         }
7458
7459       fputs (">: [", stdout);
7460       print_vma (tp->start.offset, PREFIX_HEX);
7461       fputc ('-', stdout);
7462       print_vma (tp->end.offset, PREFIX_HEX);
7463       printf ("], info at +0x%lx\n",
7464               (unsigned long) (tp->info.offset - aux->seg_base));
7465
7466       /* PR 17531: file: 86232b32.  */
7467       if (aux->info == NULL)
7468         continue;
7469
7470       /* PR 17531: file: 0997b4d1.  */
7471       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7472         {
7473           warn (_("Invalid offset %lx in table entry %ld\n"),
7474                 (long) tp->info.offset, (long) (tp - aux->table));
7475           res = FALSE;
7476           continue;
7477         }
7478
7479       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7480       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7481
7482       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7483               (unsigned) UNW_VER (stamp),
7484               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7485               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7486               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7487               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7488
7489       if (UNW_VER (stamp) != 1)
7490         {
7491           printf (_("\tUnknown version.\n"));
7492           continue;
7493         }
7494
7495       in_body = 0;
7496       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7497       /* PR 17531: file: 16ceda89.  */
7498       if (end > aux->info + aux->info_size)
7499         end = aux->info + aux->info_size;
7500       for (dp = head + 8; dp < end;)
7501         dp = unw_decode (dp, in_body, & in_body, end);
7502     }
7503
7504   free (aux->funtab);
7505
7506   return res;
7507 }
7508
7509 static bfd_boolean
7510 slurp_ia64_unwind_table (Filedata *                  filedata,
7511                          struct ia64_unw_aux_info *  aux,
7512                          Elf_Internal_Shdr *         sec)
7513 {
7514   unsigned long size, nrelas, i;
7515   Elf_Internal_Phdr * seg;
7516   struct ia64_unw_table_entry * tep;
7517   Elf_Internal_Shdr * relsec;
7518   Elf_Internal_Rela * rela;
7519   Elf_Internal_Rela * rp;
7520   unsigned char * table;
7521   unsigned char * tp;
7522   Elf_Internal_Sym * sym;
7523   const char * relname;
7524
7525   aux->table_len = 0;
7526
7527   /* First, find the starting address of the segment that includes
7528      this section: */
7529
7530   if (filedata->file_header.e_phnum)
7531     {
7532       if (! get_program_headers (filedata))
7533           return FALSE;
7534
7535       for (seg = filedata->program_headers;
7536            seg < filedata->program_headers + filedata->file_header.e_phnum;
7537            ++seg)
7538         {
7539           if (seg->p_type != PT_LOAD)
7540             continue;
7541
7542           if (sec->sh_addr >= seg->p_vaddr
7543               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7544             {
7545               aux->seg_base = seg->p_vaddr;
7546               break;
7547             }
7548         }
7549     }
7550
7551   /* Second, build the unwind table from the contents of the unwind section:  */
7552   size = sec->sh_size;
7553   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7554                                       _("unwind table"));
7555   if (!table)
7556     return FALSE;
7557
7558   aux->table_len = size / (3 * eh_addr_size);
7559   aux->table = (struct ia64_unw_table_entry *)
7560     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7561   tep = aux->table;
7562
7563   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7564     {
7565       tep->start.section = SHN_UNDEF;
7566       tep->end.section   = SHN_UNDEF;
7567       tep->info.section  = SHN_UNDEF;
7568       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7569       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7570       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7571       tep->start.offset += aux->seg_base;
7572       tep->end.offset   += aux->seg_base;
7573       tep->info.offset  += aux->seg_base;
7574     }
7575   free (table);
7576
7577   /* Third, apply any relocations to the unwind table:  */
7578   for (relsec = filedata->section_headers;
7579        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7580        ++relsec)
7581     {
7582       if (relsec->sh_type != SHT_RELA
7583           || relsec->sh_info >= filedata->file_header.e_shnum
7584           || filedata->section_headers + relsec->sh_info != sec)
7585         continue;
7586
7587       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7588                               & rela, & nrelas))
7589         {
7590           free (aux->table);
7591           aux->table = NULL;
7592           aux->table_len = 0;
7593           return FALSE;
7594         }
7595
7596       for (rp = rela; rp < rela + nrelas; ++rp)
7597         {
7598           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7599           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7600
7601           /* PR 17531: file: 9fa67536.  */
7602           if (relname == NULL)
7603             {
7604               warn (_("Skipping unknown relocation type: %u\n"),
7605                     get_reloc_type (filedata, rp->r_info));
7606               continue;
7607             }
7608
7609           if (! const_strneq (relname, "R_IA64_SEGREL"))
7610             {
7611               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7612               continue;
7613             }
7614
7615           i = rp->r_offset / (3 * eh_addr_size);
7616
7617           /* PR 17531: file: 5bc8d9bf.  */
7618           if (i >= aux->table_len)
7619             {
7620               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7621               continue;
7622             }
7623
7624           switch (rp->r_offset / eh_addr_size % 3)
7625             {
7626             case 0:
7627               aux->table[i].start.section = sym->st_shndx;
7628               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7629               break;
7630             case 1:
7631               aux->table[i].end.section   = sym->st_shndx;
7632               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7633               break;
7634             case 2:
7635               aux->table[i].info.section  = sym->st_shndx;
7636               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7637               break;
7638             default:
7639               break;
7640             }
7641         }
7642
7643       free (rela);
7644     }
7645
7646   return TRUE;
7647 }
7648
7649 static bfd_boolean
7650 ia64_process_unwind (Filedata * filedata)
7651 {
7652   Elf_Internal_Shdr * sec;
7653   Elf_Internal_Shdr * unwsec = NULL;
7654   Elf_Internal_Shdr * strsec;
7655   unsigned long i, unwcount = 0, unwstart = 0;
7656   struct ia64_unw_aux_info aux;
7657   bfd_boolean res = TRUE;
7658
7659   memset (& aux, 0, sizeof (aux));
7660
7661   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7662     {
7663       if (sec->sh_type == SHT_SYMTAB
7664           && sec->sh_link < filedata->file_header.e_shnum)
7665         {
7666           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7667
7668           strsec = filedata->section_headers + sec->sh_link;
7669           if (aux.strtab != NULL)
7670             {
7671               error (_("Multiple auxillary string tables encountered\n"));
7672               free (aux.strtab);
7673               res = FALSE;
7674             }
7675           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7676                                           1, strsec->sh_size,
7677                                           _("string table"));
7678           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7679         }
7680       else if (sec->sh_type == SHT_IA_64_UNWIND)
7681         unwcount++;
7682     }
7683
7684   if (!unwcount)
7685     printf (_("\nThere are no unwind sections in this file.\n"));
7686
7687   while (unwcount-- > 0)
7688     {
7689       char * suffix;
7690       size_t len, len2;
7691
7692       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7693            i < filedata->file_header.e_shnum; ++i, ++sec)
7694         if (sec->sh_type == SHT_IA_64_UNWIND)
7695           {
7696             unwsec = sec;
7697             break;
7698           }
7699       /* We have already counted the number of SHT_IA64_UNWIND
7700          sections so the loop above should never fail.  */
7701       assert (unwsec != NULL);
7702
7703       unwstart = i + 1;
7704       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7705
7706       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7707         {
7708           /* We need to find which section group it is in.  */
7709           struct group_list * g;
7710
7711           if (section_headers_groups == NULL
7712               || section_headers_groups [i] == NULL)
7713             i = filedata->file_header.e_shnum;
7714           else
7715             {
7716               g = section_headers_groups [i]->root;
7717
7718               for (; g != NULL; g = g->next)
7719                 {
7720                   sec = filedata->section_headers + g->section_index;
7721
7722                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7723                     break;
7724                 }
7725
7726               if (g == NULL)
7727                 i = filedata->file_header.e_shnum;
7728             }
7729         }
7730       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7731         {
7732           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7733           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7734           suffix = SECTION_NAME (unwsec) + len;
7735           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7736                ++i, ++sec)
7737             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7738                 && streq (SECTION_NAME (sec) + len2, suffix))
7739               break;
7740         }
7741       else
7742         {
7743           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7744              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7745           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7746           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7747           suffix = "";
7748           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7749             suffix = SECTION_NAME (unwsec) + len;
7750           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7751                ++i, ++sec)
7752             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7753                 && streq (SECTION_NAME (sec) + len2, suffix))
7754               break;
7755         }
7756
7757       if (i == filedata->file_header.e_shnum)
7758         {
7759           printf (_("\nCould not find unwind info section for "));
7760
7761           if (filedata->string_table == NULL)
7762             printf ("%d", unwsec->sh_name);
7763           else
7764             printf ("'%s'", printable_section_name (filedata, unwsec));
7765         }
7766       else
7767         {
7768           aux.info_addr = sec->sh_addr;
7769           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7770                                                  sec->sh_size,
7771                                                  _("unwind info"));
7772           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7773
7774           printf (_("\nUnwind section "));
7775
7776           if (filedata->string_table == NULL)
7777             printf ("%d", unwsec->sh_name);
7778           else
7779             printf ("'%s'", printable_section_name (filedata, unwsec));
7780
7781           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7782                   (unsigned long) unwsec->sh_offset,
7783                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7784
7785           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7786               && aux.table_len > 0)
7787             dump_ia64_unwind (filedata, & aux);
7788
7789           if (aux.table)
7790             free ((char *) aux.table);
7791           if (aux.info)
7792             free ((char *) aux.info);
7793           aux.table = NULL;
7794           aux.info = NULL;
7795         }
7796     }
7797
7798   if (aux.symtab)
7799     free (aux.symtab);
7800   if (aux.strtab)
7801     free ((char *) aux.strtab);
7802
7803   return res;
7804 }
7805
7806 struct hppa_unw_table_entry
7807 {
7808   struct absaddr start;
7809   struct absaddr end;
7810   unsigned int Cannot_unwind:1;                 /* 0 */
7811   unsigned int Millicode:1;                     /* 1 */
7812   unsigned int Millicode_save_sr0:1;            /* 2 */
7813   unsigned int Region_description:2;            /* 3..4 */
7814   unsigned int reserved1:1;                     /* 5 */
7815   unsigned int Entry_SR:1;                      /* 6 */
7816   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7817   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7818   unsigned int Args_stored:1;                   /* 16 */
7819   unsigned int Variable_Frame:1;                /* 17 */
7820   unsigned int Separate_Package_Body:1;         /* 18 */
7821   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7822   unsigned int Stack_Overflow_Check:1;          /* 20 */
7823   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7824   unsigned int Ada_Region:1;                    /* 22 */
7825   unsigned int cxx_info:1;                      /* 23 */
7826   unsigned int cxx_try_catch:1;                 /* 24 */
7827   unsigned int sched_entry_seq:1;               /* 25 */
7828   unsigned int reserved2:1;                     /* 26 */
7829   unsigned int Save_SP:1;                       /* 27 */
7830   unsigned int Save_RP:1;                       /* 28 */
7831   unsigned int Save_MRP_in_frame:1;             /* 29 */
7832   unsigned int extn_ptr_defined:1;              /* 30 */
7833   unsigned int Cleanup_defined:1;               /* 31 */
7834
7835   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7836   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7837   unsigned int Large_frame:1;                   /* 2 */
7838   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7839   unsigned int reserved4:1;                     /* 4 */
7840   unsigned int Total_frame_size:27;             /* 5..31 */
7841 };
7842
7843 struct hppa_unw_aux_info
7844 {
7845   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7846   unsigned long                  table_len;     /* Length of unwind table.  */
7847   bfd_vma                        seg_base;      /* Starting address of segment.  */
7848   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7849   unsigned long                  nsyms;         /* Number of symbols.  */
7850   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7851   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7852   char *                         strtab;        /* The string table.  */
7853   unsigned long                  strtab_size;   /* Size of string table.  */
7854 };
7855
7856 static bfd_boolean
7857 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7858 {
7859   struct hppa_unw_table_entry * tp;
7860   unsigned long j, nfuns;
7861   bfd_boolean res = TRUE;
7862
7863   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7864   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7865     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7866       aux->funtab[nfuns++] = aux->symtab[j];
7867   aux->nfuns = nfuns;
7868   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7869
7870   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7871     {
7872       bfd_vma offset;
7873       const char * procname;
7874
7875       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7876                                aux->strtab_size, tp->start, &procname,
7877                                &offset);
7878
7879       fputs ("\n<", stdout);
7880
7881       if (procname)
7882         {
7883           fputs (procname, stdout);
7884
7885           if (offset)
7886             printf ("+%lx", (unsigned long) offset);
7887         }
7888
7889       fputs (">: [", stdout);
7890       print_vma (tp->start.offset, PREFIX_HEX);
7891       fputc ('-', stdout);
7892       print_vma (tp->end.offset, PREFIX_HEX);
7893       printf ("]\n\t");
7894
7895 #define PF(_m) if (tp->_m) printf (#_m " ");
7896 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7897       PF(Cannot_unwind);
7898       PF(Millicode);
7899       PF(Millicode_save_sr0);
7900       /* PV(Region_description);  */
7901       PF(Entry_SR);
7902       PV(Entry_FR);
7903       PV(Entry_GR);
7904       PF(Args_stored);
7905       PF(Variable_Frame);
7906       PF(Separate_Package_Body);
7907       PF(Frame_Extension_Millicode);
7908       PF(Stack_Overflow_Check);
7909       PF(Two_Instruction_SP_Increment);
7910       PF(Ada_Region);
7911       PF(cxx_info);
7912       PF(cxx_try_catch);
7913       PF(sched_entry_seq);
7914       PF(Save_SP);
7915       PF(Save_RP);
7916       PF(Save_MRP_in_frame);
7917       PF(extn_ptr_defined);
7918       PF(Cleanup_defined);
7919       PF(MPE_XL_interrupt_marker);
7920       PF(HP_UX_interrupt_marker);
7921       PF(Large_frame);
7922       PF(Pseudo_SP_Set);
7923       PV(Total_frame_size);
7924 #undef PF
7925 #undef PV
7926     }
7927
7928   printf ("\n");
7929
7930   free (aux->funtab);
7931
7932   return res;
7933 }
7934
7935 static bfd_boolean
7936 slurp_hppa_unwind_table (Filedata *                  filedata,
7937                          struct hppa_unw_aux_info *  aux,
7938                          Elf_Internal_Shdr *         sec)
7939 {
7940   unsigned long size, unw_ent_size, nentries, nrelas, i;
7941   Elf_Internal_Phdr * seg;
7942   struct hppa_unw_table_entry * tep;
7943   Elf_Internal_Shdr * relsec;
7944   Elf_Internal_Rela * rela;
7945   Elf_Internal_Rela * rp;
7946   unsigned char * table;
7947   unsigned char * tp;
7948   Elf_Internal_Sym * sym;
7949   const char * relname;
7950
7951   /* First, find the starting address of the segment that includes
7952      this section.  */
7953   if (filedata->file_header.e_phnum)
7954     {
7955       if (! get_program_headers (filedata))
7956         return FALSE;
7957
7958       for (seg = filedata->program_headers;
7959            seg < filedata->program_headers + filedata->file_header.e_phnum;
7960            ++seg)
7961         {
7962           if (seg->p_type != PT_LOAD)
7963             continue;
7964
7965           if (sec->sh_addr >= seg->p_vaddr
7966               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7967             {
7968               aux->seg_base = seg->p_vaddr;
7969               break;
7970             }
7971         }
7972     }
7973
7974   /* Second, build the unwind table from the contents of the unwind
7975      section.  */
7976   size = sec->sh_size;
7977   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7978                                       _("unwind table"));
7979   if (!table)
7980     return FALSE;
7981
7982   unw_ent_size = 16;
7983   nentries = size / unw_ent_size;
7984   size = unw_ent_size * nentries;
7985
7986   tep = aux->table = (struct hppa_unw_table_entry *)
7987       xcmalloc (nentries, sizeof (aux->table[0]));
7988
7989   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7990     {
7991       unsigned int tmp1, tmp2;
7992
7993       tep->start.section = SHN_UNDEF;
7994       tep->end.section   = SHN_UNDEF;
7995
7996       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7997       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7998       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7999       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8000
8001       tep->start.offset += aux->seg_base;
8002       tep->end.offset   += aux->seg_base;
8003
8004       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8005       tep->Millicode = (tmp1 >> 30) & 0x1;
8006       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8007       tep->Region_description = (tmp1 >> 27) & 0x3;
8008       tep->reserved1 = (tmp1 >> 26) & 0x1;
8009       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8010       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8011       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8012       tep->Args_stored = (tmp1 >> 15) & 0x1;
8013       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8014       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8015       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8016       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8017       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8018       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8019       tep->cxx_info = (tmp1 >> 8) & 0x1;
8020       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8021       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8022       tep->reserved2 = (tmp1 >> 5) & 0x1;
8023       tep->Save_SP = (tmp1 >> 4) & 0x1;
8024       tep->Save_RP = (tmp1 >> 3) & 0x1;
8025       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8026       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8027       tep->Cleanup_defined = tmp1 & 0x1;
8028
8029       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8030       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8031       tep->Large_frame = (tmp2 >> 29) & 0x1;
8032       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8033       tep->reserved4 = (tmp2 >> 27) & 0x1;
8034       tep->Total_frame_size = tmp2 & 0x7ffffff;
8035     }
8036   free (table);
8037
8038   /* Third, apply any relocations to the unwind table.  */
8039   for (relsec = filedata->section_headers;
8040        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8041        ++relsec)
8042     {
8043       if (relsec->sh_type != SHT_RELA
8044           || relsec->sh_info >= filedata->file_header.e_shnum
8045           || filedata->section_headers + relsec->sh_info != sec)
8046         continue;
8047
8048       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8049                               & rela, & nrelas))
8050         return FALSE;
8051
8052       for (rp = rela; rp < rela + nrelas; ++rp)
8053         {
8054           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8055           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8056
8057           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8058           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8059             {
8060               warn (_("Skipping unexpected relocation type %s\n"), relname);
8061               continue;
8062             }
8063
8064           i = rp->r_offset / unw_ent_size;
8065
8066           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8067             {
8068             case 0:
8069               aux->table[i].start.section = sym->st_shndx;
8070               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8071               break;
8072             case 1:
8073               aux->table[i].end.section   = sym->st_shndx;
8074               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8075               break;
8076             default:
8077               break;
8078             }
8079         }
8080
8081       free (rela);
8082     }
8083
8084   aux->table_len = nentries;
8085
8086   return TRUE;
8087 }
8088
8089 static bfd_boolean
8090 hppa_process_unwind (Filedata * filedata)
8091 {
8092   struct hppa_unw_aux_info aux;
8093   Elf_Internal_Shdr * unwsec = NULL;
8094   Elf_Internal_Shdr * strsec;
8095   Elf_Internal_Shdr * sec;
8096   unsigned long i;
8097   bfd_boolean res = TRUE;
8098
8099   if (filedata->string_table == NULL)
8100     return FALSE;
8101
8102   memset (& aux, 0, sizeof (aux));
8103
8104   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8105     {
8106       if (sec->sh_type == SHT_SYMTAB
8107           && sec->sh_link < filedata->file_header.e_shnum)
8108         {
8109           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8110
8111           strsec = filedata->section_headers + sec->sh_link;
8112           if (aux.strtab != NULL)
8113             {
8114               error (_("Multiple auxillary string tables encountered\n"));
8115               free (aux.strtab);
8116               res = FALSE;
8117             }
8118           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8119                                           1, strsec->sh_size,
8120                                           _("string table"));
8121           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8122         }
8123       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8124         unwsec = sec;
8125     }
8126
8127   if (!unwsec)
8128     printf (_("\nThere are no unwind sections in this file.\n"));
8129
8130   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8131     {
8132       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8133         {
8134           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8135
8136           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8137                             "contains %lu entry:\n",
8138                             "\nUnwind section '%s' at offset 0x%lx "
8139                             "contains %lu entries:\n",
8140                             num_unwind),
8141                   printable_section_name (filedata, sec),
8142                   (unsigned long) sec->sh_offset,
8143                   num_unwind);
8144
8145           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8146             res = FALSE;
8147
8148           if (res && aux.table_len > 0)
8149             {
8150               if (! dump_hppa_unwind (filedata, &aux))
8151                 res = FALSE;
8152             }
8153
8154           if (aux.table)
8155             free ((char *) aux.table);
8156           aux.table = NULL;
8157         }
8158     }
8159
8160   if (aux.symtab)
8161     free (aux.symtab);
8162   if (aux.strtab)
8163     free ((char *) aux.strtab);
8164
8165   return res;
8166 }
8167
8168 struct arm_section
8169 {
8170   unsigned char *      data;            /* The unwind data.  */
8171   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8172   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8173   unsigned long        nrelas;          /* The number of relocations.  */
8174   unsigned int         rel_type;        /* REL or RELA ?  */
8175   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8176 };
8177
8178 struct arm_unw_aux_info
8179 {
8180   Filedata *          filedata;         /* The file containing the unwind sections.  */
8181   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8182   unsigned long       nsyms;            /* Number of symbols.  */
8183   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8184   unsigned long       nfuns;            /* Number of these symbols.  */
8185   char *              strtab;           /* The file's string table.  */
8186   unsigned long       strtab_size;      /* Size of string table.  */
8187 };
8188
8189 static const char *
8190 arm_print_vma_and_name (Filedata *                 filedata,
8191                         struct arm_unw_aux_info *  aux,
8192                         bfd_vma                    fn,
8193                         struct absaddr             addr)
8194 {
8195   const char *procname;
8196   bfd_vma sym_offset;
8197
8198   if (addr.section == SHN_UNDEF)
8199     addr.offset = fn;
8200
8201   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8202                            aux->strtab_size, addr, &procname,
8203                            &sym_offset);
8204
8205   print_vma (fn, PREFIX_HEX);
8206
8207   if (procname)
8208     {
8209       fputs (" <", stdout);
8210       fputs (procname, stdout);
8211
8212       if (sym_offset)
8213         printf ("+0x%lx", (unsigned long) sym_offset);
8214       fputc ('>', stdout);
8215     }
8216
8217   return procname;
8218 }
8219
8220 static void
8221 arm_free_section (struct arm_section *arm_sec)
8222 {
8223   if (arm_sec->data != NULL)
8224     free (arm_sec->data);
8225
8226   if (arm_sec->rela != NULL)
8227     free (arm_sec->rela);
8228 }
8229
8230 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8231       cached section and install SEC instead.
8232    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8233       and return its valued in * WORDP, relocating if necessary.
8234    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8235       relocation's offset in ADDR.
8236    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8237       into the string table of the symbol associated with the reloc.  If no
8238       reloc was applied store -1 there.
8239    5) Return TRUE upon success, FALSE otherwise.  */
8240
8241 static bfd_boolean
8242 get_unwind_section_word (Filedata *                 filedata,
8243                          struct arm_unw_aux_info *  aux,
8244                          struct arm_section *       arm_sec,
8245                          Elf_Internal_Shdr *        sec,
8246                          bfd_vma                    word_offset,
8247                          unsigned int *             wordp,
8248                          struct absaddr *           addr,
8249                          bfd_vma *                  sym_name)
8250 {
8251   Elf_Internal_Rela *rp;
8252   Elf_Internal_Sym *sym;
8253   const char * relname;
8254   unsigned int word;
8255   bfd_boolean wrapped;
8256
8257   if (sec == NULL || arm_sec == NULL)
8258     return FALSE;
8259
8260   addr->section = SHN_UNDEF;
8261   addr->offset = 0;
8262
8263   if (sym_name != NULL)
8264     *sym_name = (bfd_vma) -1;
8265
8266   /* If necessary, update the section cache.  */
8267   if (sec != arm_sec->sec)
8268     {
8269       Elf_Internal_Shdr *relsec;
8270
8271       arm_free_section (arm_sec);
8272
8273       arm_sec->sec = sec;
8274       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8275                                 sec->sh_size, _("unwind data"));
8276       arm_sec->rela = NULL;
8277       arm_sec->nrelas = 0;
8278
8279       for (relsec = filedata->section_headers;
8280            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8281            ++relsec)
8282         {
8283           if (relsec->sh_info >= filedata->file_header.e_shnum
8284               || filedata->section_headers + relsec->sh_info != sec
8285               /* PR 15745: Check the section type as well.  */
8286               || (relsec->sh_type != SHT_REL
8287                   && relsec->sh_type != SHT_RELA))
8288             continue;
8289
8290           arm_sec->rel_type = relsec->sh_type;
8291           if (relsec->sh_type == SHT_REL)
8292             {
8293               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8294                                      relsec->sh_size,
8295                                      & arm_sec->rela, & arm_sec->nrelas))
8296                 return FALSE;
8297             }
8298           else /* relsec->sh_type == SHT_RELA */
8299             {
8300               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8301                                       relsec->sh_size,
8302                                       & arm_sec->rela, & arm_sec->nrelas))
8303                 return FALSE;
8304             }
8305           break;
8306         }
8307
8308       arm_sec->next_rela = arm_sec->rela;
8309     }
8310
8311   /* If there is no unwind data we can do nothing.  */
8312   if (arm_sec->data == NULL)
8313     return FALSE;
8314
8315   /* If the offset is invalid then fail.  */
8316   if (/* PR 21343 *//* PR 18879 */
8317       sec->sh_size < 4
8318       || word_offset > (sec->sh_size - 4)
8319       || ((bfd_signed_vma) word_offset) < 0)
8320     return FALSE;
8321
8322   /* Get the word at the required offset.  */
8323   word = byte_get (arm_sec->data + word_offset, 4);
8324
8325   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8326   if (arm_sec->rela == NULL)
8327     {
8328       * wordp = word;
8329       return TRUE;
8330     }
8331
8332   /* Look through the relocs to find the one that applies to the provided offset.  */
8333   wrapped = FALSE;
8334   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8335     {
8336       bfd_vma prelval, offset;
8337
8338       if (rp->r_offset > word_offset && !wrapped)
8339         {
8340           rp = arm_sec->rela;
8341           wrapped = TRUE;
8342         }
8343       if (rp->r_offset > word_offset)
8344         break;
8345
8346       if (rp->r_offset & 3)
8347         {
8348           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8349                 (unsigned long) rp->r_offset);
8350           continue;
8351         }
8352
8353       if (rp->r_offset < word_offset)
8354         continue;
8355
8356       /* PR 17531: file: 027-161405-0.004  */
8357       if (aux->symtab == NULL)
8358         continue;
8359
8360       if (arm_sec->rel_type == SHT_REL)
8361         {
8362           offset = word & 0x7fffffff;
8363           if (offset & 0x40000000)
8364             offset |= ~ (bfd_vma) 0x7fffffff;
8365         }
8366       else if (arm_sec->rel_type == SHT_RELA)
8367         offset = rp->r_addend;
8368       else
8369         {
8370           error (_("Unknown section relocation type %d encountered\n"),
8371                  arm_sec->rel_type);
8372           break;
8373         }
8374
8375       /* PR 17531 file: 027-1241568-0.004.  */
8376       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8377         {
8378           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8379                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8380           break;
8381         }
8382
8383       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8384       offset += sym->st_value;
8385       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8386
8387       /* Check that we are processing the expected reloc type.  */
8388       if (filedata->file_header.e_machine == EM_ARM)
8389         {
8390           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8391           if (relname == NULL)
8392             {
8393               warn (_("Skipping unknown ARM relocation type: %d\n"),
8394                     (int) ELF32_R_TYPE (rp->r_info));
8395               continue;
8396             }
8397
8398           if (streq (relname, "R_ARM_NONE"))
8399               continue;
8400
8401           if (! streq (relname, "R_ARM_PREL31"))
8402             {
8403               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8404               continue;
8405             }
8406         }
8407       else if (filedata->file_header.e_machine == EM_TI_C6000)
8408         {
8409           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8410           if (relname == NULL)
8411             {
8412               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8413                     (int) ELF32_R_TYPE (rp->r_info));
8414               continue;
8415             }
8416
8417           if (streq (relname, "R_C6000_NONE"))
8418             continue;
8419
8420           if (! streq (relname, "R_C6000_PREL31"))
8421             {
8422               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8423               continue;
8424             }
8425
8426           prelval >>= 1;
8427         }
8428       else
8429         {
8430           /* This function currently only supports ARM and TI unwinders.  */
8431           warn (_("Only TI and ARM unwinders are currently supported\n"));
8432           break;
8433         }
8434
8435       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8436       addr->section = sym->st_shndx;
8437       addr->offset = offset;
8438
8439       if (sym_name)
8440         * sym_name = sym->st_name;
8441       break;
8442     }
8443
8444   *wordp = word;
8445   arm_sec->next_rela = rp;
8446
8447   return TRUE;
8448 }
8449
8450 static const char *tic6x_unwind_regnames[16] =
8451 {
8452   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8453   "A14", "A13", "A12", "A11", "A10",
8454   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8455 };
8456
8457 static void
8458 decode_tic6x_unwind_regmask (unsigned int mask)
8459 {
8460   int i;
8461
8462   for (i = 12; mask; mask >>= 1, i--)
8463     {
8464       if (mask & 1)
8465         {
8466           fputs (tic6x_unwind_regnames[i], stdout);
8467           if (mask > 1)
8468             fputs (", ", stdout);
8469         }
8470     }
8471 }
8472
8473 #define ADVANCE                                                 \
8474   if (remaining == 0 && more_words)                             \
8475     {                                                           \
8476       data_offset += 4;                                         \
8477       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8478                                      data_offset, & word, & addr, NULL))        \
8479         return FALSE;                                           \
8480       remaining = 4;                                            \
8481       more_words--;                                             \
8482     }                                                           \
8483
8484 #define GET_OP(OP)                      \
8485   ADVANCE;                              \
8486   if (remaining)                        \
8487     {                                   \
8488       remaining--;                      \
8489       (OP) = word >> 24;                \
8490       word <<= 8;                       \
8491     }                                   \
8492   else                                  \
8493     {                                   \
8494       printf (_("[Truncated opcode]\n"));       \
8495       return FALSE;                     \
8496     }                                   \
8497   printf ("0x%02x ", OP)
8498
8499 static bfd_boolean
8500 decode_arm_unwind_bytecode (Filedata *                 filedata,
8501                             struct arm_unw_aux_info *  aux,
8502                             unsigned int               word,
8503                             unsigned int               remaining,
8504                             unsigned int               more_words,
8505                             bfd_vma                    data_offset,
8506                             Elf_Internal_Shdr *        data_sec,
8507                             struct arm_section *       data_arm_sec)
8508 {
8509   struct absaddr addr;
8510   bfd_boolean res = TRUE;
8511
8512   /* Decode the unwinding instructions.  */
8513   while (1)
8514     {
8515       unsigned int op, op2;
8516
8517       ADVANCE;
8518       if (remaining == 0)
8519         break;
8520       remaining--;
8521       op = word >> 24;
8522       word <<= 8;
8523
8524       printf ("  0x%02x ", op);
8525
8526       if ((op & 0xc0) == 0x00)
8527         {
8528           int offset = ((op & 0x3f) << 2) + 4;
8529
8530           printf ("     vsp = vsp + %d", offset);
8531         }
8532       else if ((op & 0xc0) == 0x40)
8533         {
8534           int offset = ((op & 0x3f) << 2) + 4;
8535
8536           printf ("     vsp = vsp - %d", offset);
8537         }
8538       else if ((op & 0xf0) == 0x80)
8539         {
8540           GET_OP (op2);
8541           if (op == 0x80 && op2 == 0)
8542             printf (_("Refuse to unwind"));
8543           else
8544             {
8545               unsigned int mask = ((op & 0x0f) << 8) | op2;
8546               bfd_boolean first = TRUE;
8547               int i;
8548
8549               printf ("pop {");
8550               for (i = 0; i < 12; i++)
8551                 if (mask & (1 << i))
8552                   {
8553                     if (first)
8554                       first = FALSE;
8555                     else
8556                       printf (", ");
8557                     printf ("r%d", 4 + i);
8558                   }
8559               printf ("}");
8560             }
8561         }
8562       else if ((op & 0xf0) == 0x90)
8563         {
8564           if (op == 0x9d || op == 0x9f)
8565             printf (_("     [Reserved]"));
8566           else
8567             printf ("     vsp = r%d", op & 0x0f);
8568         }
8569       else if ((op & 0xf0) == 0xa0)
8570         {
8571           int end = 4 + (op & 0x07);
8572           bfd_boolean first = TRUE;
8573           int i;
8574
8575           printf ("     pop {");
8576           for (i = 4; i <= end; i++)
8577             {
8578               if (first)
8579                 first = FALSE;
8580               else
8581                 printf (", ");
8582               printf ("r%d", i);
8583             }
8584           if (op & 0x08)
8585             {
8586               if (!first)
8587                 printf (", ");
8588               printf ("r14");
8589             }
8590           printf ("}");
8591         }
8592       else if (op == 0xb0)
8593         printf (_("     finish"));
8594       else if (op == 0xb1)
8595         {
8596           GET_OP (op2);
8597           if (op2 == 0 || (op2 & 0xf0) != 0)
8598             printf (_("[Spare]"));
8599           else
8600             {
8601               unsigned int mask = op2 & 0x0f;
8602               bfd_boolean first = TRUE;
8603               int i;
8604
8605               printf ("pop {");
8606               for (i = 0; i < 12; i++)
8607                 if (mask & (1 << i))
8608                   {
8609                     if (first)
8610                       first = FALSE;
8611                     else
8612                       printf (", ");
8613                     printf ("r%d", i);
8614                   }
8615               printf ("}");
8616             }
8617         }
8618       else if (op == 0xb2)
8619         {
8620           unsigned char buf[9];
8621           unsigned int i, len;
8622           unsigned long offset;
8623
8624           for (i = 0; i < sizeof (buf); i++)
8625             {
8626               GET_OP (buf[i]);
8627               if ((buf[i] & 0x80) == 0)
8628                 break;
8629             }
8630           if (i == sizeof (buf))
8631             {
8632               error (_("corrupt change to vsp"));
8633               res = FALSE;
8634             }
8635           else
8636             {
8637               offset = read_uleb128 (buf, &len, buf + i + 1);
8638               assert (len == i + 1);
8639               offset = offset * 4 + 0x204;
8640               printf ("vsp = vsp + %ld", offset);
8641             }
8642         }
8643       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8644         {
8645           unsigned int first, last;
8646
8647           GET_OP (op2);
8648           first = op2 >> 4;
8649           last = op2 & 0x0f;
8650           if (op == 0xc8)
8651             first = first + 16;
8652           printf ("pop {D%d", first);
8653           if (last)
8654             printf ("-D%d", first + last);
8655           printf ("}");
8656         }
8657       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8658         {
8659           unsigned int count = op & 0x07;
8660
8661           printf ("pop {D8");
8662           if (count)
8663             printf ("-D%d", 8 + count);
8664           printf ("}");
8665         }
8666       else if (op >= 0xc0 && op <= 0xc5)
8667         {
8668           unsigned int count = op & 0x07;
8669
8670           printf ("     pop {wR10");
8671           if (count)
8672             printf ("-wR%d", 10 + count);
8673           printf ("}");
8674         }
8675       else if (op == 0xc6)
8676         {
8677           unsigned int first, last;
8678
8679           GET_OP (op2);
8680           first = op2 >> 4;
8681           last = op2 & 0x0f;
8682           printf ("pop {wR%d", first);
8683           if (last)
8684             printf ("-wR%d", first + last);
8685           printf ("}");
8686         }
8687       else if (op == 0xc7)
8688         {
8689           GET_OP (op2);
8690           if (op2 == 0 || (op2 & 0xf0) != 0)
8691             printf (_("[Spare]"));
8692           else
8693             {
8694               unsigned int mask = op2 & 0x0f;
8695               bfd_boolean first = TRUE;
8696               int i;
8697
8698               printf ("pop {");
8699               for (i = 0; i < 4; i++)
8700                 if (mask & (1 << i))
8701                   {
8702                     if (first)
8703                       first = FALSE;
8704                     else
8705                       printf (", ");
8706                     printf ("wCGR%d", i);
8707                   }
8708               printf ("}");
8709             }
8710         }
8711       else
8712         {
8713           printf (_("     [unsupported opcode]"));
8714           res = FALSE;
8715         }
8716
8717       printf ("\n");
8718     }
8719
8720   return res;
8721 }
8722
8723 static bfd_boolean
8724 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8725                               struct arm_unw_aux_info *  aux,
8726                               unsigned int               word,
8727                               unsigned int               remaining,
8728                               unsigned int               more_words,
8729                               bfd_vma                    data_offset,
8730                               Elf_Internal_Shdr *        data_sec,
8731                               struct arm_section *       data_arm_sec)
8732 {
8733   struct absaddr addr;
8734
8735   /* Decode the unwinding instructions.  */
8736   while (1)
8737     {
8738       unsigned int op, op2;
8739
8740       ADVANCE;
8741       if (remaining == 0)
8742         break;
8743       remaining--;
8744       op = word >> 24;
8745       word <<= 8;
8746
8747       printf ("  0x%02x ", op);
8748
8749       if ((op & 0xc0) == 0x00)
8750         {
8751           int offset = ((op & 0x3f) << 3) + 8;
8752           printf ("     sp = sp + %d", offset);
8753         }
8754       else if ((op & 0xc0) == 0x80)
8755         {
8756           GET_OP (op2);
8757           if (op == 0x80 && op2 == 0)
8758             printf (_("Refuse to unwind"));
8759           else
8760             {
8761               unsigned int mask = ((op & 0x1f) << 8) | op2;
8762               if (op & 0x20)
8763                 printf ("pop compact {");
8764               else
8765                 printf ("pop {");
8766
8767               decode_tic6x_unwind_regmask (mask);
8768               printf("}");
8769             }
8770         }
8771       else if ((op & 0xf0) == 0xc0)
8772         {
8773           unsigned int reg;
8774           unsigned int nregs;
8775           unsigned int i;
8776           const char *name;
8777           struct
8778           {
8779             unsigned int offset;
8780             unsigned int reg;
8781           } regpos[16];
8782
8783           /* Scan entire instruction first so that GET_OP output is not
8784              interleaved with disassembly.  */
8785           nregs = 0;
8786           for (i = 0; nregs < (op & 0xf); i++)
8787             {
8788               GET_OP (op2);
8789               reg = op2 >> 4;
8790               if (reg != 0xf)
8791                 {
8792                   regpos[nregs].offset = i * 2;
8793                   regpos[nregs].reg = reg;
8794                   nregs++;
8795                 }
8796
8797               reg = op2 & 0xf;
8798               if (reg != 0xf)
8799                 {
8800                   regpos[nregs].offset = i * 2 + 1;
8801                   regpos[nregs].reg = reg;
8802                   nregs++;
8803                 }
8804             }
8805
8806           printf (_("pop frame {"));
8807           reg = nregs - 1;
8808           for (i = i * 2; i > 0; i--)
8809             {
8810               if (regpos[reg].offset == i - 1)
8811                 {
8812                   name = tic6x_unwind_regnames[regpos[reg].reg];
8813                   if (reg > 0)
8814                     reg--;
8815                 }
8816               else
8817                 name = _("[pad]");
8818
8819               fputs (name, stdout);
8820               if (i > 1)
8821                 printf (", ");
8822             }
8823
8824           printf ("}");
8825         }
8826       else if (op == 0xd0)
8827         printf ("     MOV FP, SP");
8828       else if (op == 0xd1)
8829         printf ("     __c6xabi_pop_rts");
8830       else if (op == 0xd2)
8831         {
8832           unsigned char buf[9];
8833           unsigned int i, len;
8834           unsigned long offset;
8835
8836           for (i = 0; i < sizeof (buf); i++)
8837             {
8838               GET_OP (buf[i]);
8839               if ((buf[i] & 0x80) == 0)
8840                 break;
8841             }
8842           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8843           if (i == sizeof (buf))
8844             {
8845               warn (_("Corrupt stack pointer adjustment detected\n"));
8846               return FALSE;
8847             }
8848
8849           offset = read_uleb128 (buf, &len, buf + i + 1);
8850           assert (len == i + 1);
8851           offset = offset * 8 + 0x408;
8852           printf (_("sp = sp + %ld"), offset);
8853         }
8854       else if ((op & 0xf0) == 0xe0)
8855         {
8856           if ((op & 0x0f) == 7)
8857             printf ("     RETURN");
8858           else
8859             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8860         }
8861       else
8862         {
8863           printf (_("     [unsupported opcode]"));
8864         }
8865       putchar ('\n');
8866     }
8867
8868   return TRUE;
8869 }
8870
8871 static bfd_vma
8872 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8873 {
8874   bfd_vma offset;
8875
8876   offset = word & 0x7fffffff;
8877   if (offset & 0x40000000)
8878     offset |= ~ (bfd_vma) 0x7fffffff;
8879
8880   if (filedata->file_header.e_machine == EM_TI_C6000)
8881     offset <<= 1;
8882
8883   return offset + where;
8884 }
8885
8886 static bfd_boolean
8887 decode_arm_unwind (Filedata *                 filedata,
8888                    struct arm_unw_aux_info *  aux,
8889                    unsigned int               word,
8890                    unsigned int               remaining,
8891                    bfd_vma                    data_offset,
8892                    Elf_Internal_Shdr *        data_sec,
8893                    struct arm_section *       data_arm_sec)
8894 {
8895   int per_index;
8896   unsigned int more_words = 0;
8897   struct absaddr addr;
8898   bfd_vma sym_name = (bfd_vma) -1;
8899   bfd_boolean res = TRUE;
8900
8901   if (remaining == 0)
8902     {
8903       /* Fetch the first word.
8904          Note - when decoding an object file the address extracted
8905          here will always be 0.  So we also pass in the sym_name
8906          parameter so that we can find the symbol associated with
8907          the personality routine.  */
8908       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8909                                      & word, & addr, & sym_name))
8910         return FALSE;
8911
8912       remaining = 4;
8913     }
8914
8915   if ((word & 0x80000000) == 0)
8916     {
8917       /* Expand prel31 for personality routine.  */
8918       bfd_vma fn;
8919       const char *procname;
8920
8921       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8922       printf (_("  Personality routine: "));
8923       if (fn == 0
8924           && addr.section == SHN_UNDEF && addr.offset == 0
8925           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8926         {
8927           procname = aux->strtab + sym_name;
8928           print_vma (fn, PREFIX_HEX);
8929           if (procname)
8930             {
8931               fputs (" <", stdout);
8932               fputs (procname, stdout);
8933               fputc ('>', stdout);
8934             }
8935         }
8936       else
8937         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8938       fputc ('\n', stdout);
8939
8940       /* The GCC personality routines use the standard compact
8941          encoding, starting with one byte giving the number of
8942          words.  */
8943       if (procname != NULL
8944           && (const_strneq (procname, "__gcc_personality_v0")
8945               || const_strneq (procname, "__gxx_personality_v0")
8946               || const_strneq (procname, "__gcj_personality_v0")
8947               || const_strneq (procname, "__gnu_objc_personality_v0")))
8948         {
8949           remaining = 0;
8950           more_words = 1;
8951           ADVANCE;
8952           if (!remaining)
8953             {
8954               printf (_("  [Truncated data]\n"));
8955               return FALSE;
8956             }
8957           more_words = word >> 24;
8958           word <<= 8;
8959           remaining--;
8960           per_index = -1;
8961         }
8962       else
8963         return TRUE;
8964     }
8965   else
8966     {
8967       /* ARM EHABI Section 6.3:
8968
8969          An exception-handling table entry for the compact model looks like:
8970
8971            31 30-28 27-24 23-0
8972            -- ----- ----- ----
8973             1   0   index Data for personalityRoutine[index]    */
8974
8975       if (filedata->file_header.e_machine == EM_ARM
8976           && (word & 0x70000000))
8977         {
8978           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8979           res = FALSE;
8980         }
8981
8982       per_index = (word >> 24) & 0x7f;
8983       printf (_("  Compact model index: %d\n"), per_index);
8984       if (per_index == 0)
8985         {
8986           more_words = 0;
8987           word <<= 8;
8988           remaining--;
8989         }
8990       else if (per_index < 3)
8991         {
8992           more_words = (word >> 16) & 0xff;
8993           word <<= 16;
8994           remaining -= 2;
8995         }
8996     }
8997
8998   switch (filedata->file_header.e_machine)
8999     {
9000     case EM_ARM:
9001       if (per_index < 3)
9002         {
9003           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9004                                             data_offset, data_sec, data_arm_sec))
9005             res = FALSE;
9006         }
9007       else
9008         {
9009           warn (_("Unknown ARM compact model index encountered\n"));
9010           printf (_("  [reserved]\n"));
9011           res = FALSE;
9012         }
9013       break;
9014
9015     case EM_TI_C6000:
9016       if (per_index < 3)
9017         {
9018           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9019                                               data_offset, data_sec, data_arm_sec))
9020             res = FALSE;
9021         }
9022       else if (per_index < 5)
9023         {
9024           if (((word >> 17) & 0x7f) == 0x7f)
9025             printf (_("  Restore stack from frame pointer\n"));
9026           else
9027             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9028           printf (_("  Registers restored: "));
9029           if (per_index == 4)
9030             printf (" (compact) ");
9031           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9032           putchar ('\n');
9033           printf (_("  Return register: %s\n"),
9034                   tic6x_unwind_regnames[word & 0xf]);
9035         }
9036       else
9037         printf (_("  [reserved (%d)]\n"), per_index);
9038       break;
9039
9040     default:
9041       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9042              filedata->file_header.e_machine);
9043       res = FALSE;
9044     }
9045
9046   /* Decode the descriptors.  Not implemented.  */
9047
9048   return res;
9049 }
9050
9051 static bfd_boolean
9052 dump_arm_unwind (Filedata *                 filedata,
9053                  struct arm_unw_aux_info *  aux,
9054                  Elf_Internal_Shdr *        exidx_sec)
9055 {
9056   struct arm_section exidx_arm_sec, extab_arm_sec;
9057   unsigned int i, exidx_len;
9058   unsigned long j, nfuns;
9059   bfd_boolean res = TRUE;
9060
9061   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9062   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9063   exidx_len = exidx_sec->sh_size / 8;
9064
9065   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9066   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9067     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9068       aux->funtab[nfuns++] = aux->symtab[j];
9069   aux->nfuns = nfuns;
9070   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9071
9072   for (i = 0; i < exidx_len; i++)
9073     {
9074       unsigned int exidx_fn, exidx_entry;
9075       struct absaddr fn_addr, entry_addr;
9076       bfd_vma fn;
9077
9078       fputc ('\n', stdout);
9079
9080       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9081                                      8 * i, & exidx_fn, & fn_addr, NULL)
9082           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9083                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9084         {
9085           free (aux->funtab);
9086           arm_free_section (& exidx_arm_sec);
9087           arm_free_section (& extab_arm_sec);
9088           return FALSE;
9089         }
9090
9091       /* ARM EHABI, Section 5:
9092          An index table entry consists of 2 words.
9093          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9094       if (exidx_fn & 0x80000000)
9095         {
9096           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9097           res = FALSE;
9098         }
9099
9100       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9101
9102       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9103       fputs (": ", stdout);
9104
9105       if (exidx_entry == 1)
9106         {
9107           print_vma (exidx_entry, PREFIX_HEX);
9108           fputs (" [cantunwind]\n", stdout);
9109         }
9110       else if (exidx_entry & 0x80000000)
9111         {
9112           print_vma (exidx_entry, PREFIX_HEX);
9113           fputc ('\n', stdout);
9114           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9115         }
9116       else
9117         {
9118           bfd_vma table, table_offset = 0;
9119           Elf_Internal_Shdr *table_sec;
9120
9121           fputs ("@", stdout);
9122           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9123           print_vma (table, PREFIX_HEX);
9124           printf ("\n");
9125
9126           /* Locate the matching .ARM.extab.  */
9127           if (entry_addr.section != SHN_UNDEF
9128               && entry_addr.section < filedata->file_header.e_shnum)
9129             {
9130               table_sec = filedata->section_headers + entry_addr.section;
9131               table_offset = entry_addr.offset;
9132               /* PR 18879 */
9133               if (table_offset > table_sec->sh_size
9134                   || ((bfd_signed_vma) table_offset) < 0)
9135                 {
9136                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9137                         (unsigned long) table_offset,
9138                         printable_section_name (filedata, table_sec));
9139                   res = FALSE;
9140                   continue;
9141                 }
9142             }
9143           else
9144             {
9145               table_sec = find_section_by_address (filedata, table);
9146               if (table_sec != NULL)
9147                 table_offset = table - table_sec->sh_addr;
9148             }
9149
9150           if (table_sec == NULL)
9151             {
9152               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9153                     (unsigned long) table);
9154               res = FALSE;
9155               continue;
9156             }
9157
9158           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9159                                    &extab_arm_sec))
9160             res = FALSE;
9161         }
9162     }
9163
9164   printf ("\n");
9165
9166   free (aux->funtab);
9167   arm_free_section (&exidx_arm_sec);
9168   arm_free_section (&extab_arm_sec);
9169
9170   return res;
9171 }
9172
9173 /* Used for both ARM and C6X unwinding tables.  */
9174
9175 static bfd_boolean
9176 arm_process_unwind (Filedata * filedata)
9177 {
9178   struct arm_unw_aux_info aux;
9179   Elf_Internal_Shdr *unwsec = NULL;
9180   Elf_Internal_Shdr *strsec;
9181   Elf_Internal_Shdr *sec;
9182   unsigned long i;
9183   unsigned int sec_type;
9184   bfd_boolean res = TRUE;
9185
9186   switch (filedata->file_header.e_machine)
9187     {
9188     case EM_ARM:
9189       sec_type = SHT_ARM_EXIDX;
9190       break;
9191
9192     case EM_TI_C6000:
9193       sec_type = SHT_C6000_UNWIND;
9194       break;
9195
9196     default:
9197       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9198              filedata->file_header.e_machine);
9199       return FALSE;
9200     }
9201
9202   if (filedata->string_table == NULL)
9203     return FALSE;
9204
9205   memset (& aux, 0, sizeof (aux));
9206   aux.filedata = filedata;
9207
9208   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9209     {
9210       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9211         {
9212           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9213
9214           strsec = filedata->section_headers + sec->sh_link;
9215
9216           /* PR binutils/17531 file: 011-12666-0.004.  */
9217           if (aux.strtab != NULL)
9218             {
9219               error (_("Multiple string tables found in file.\n"));
9220               free (aux.strtab);
9221               res = FALSE;
9222             }
9223           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9224                                  1, strsec->sh_size, _("string table"));
9225           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9226         }
9227       else if (sec->sh_type == sec_type)
9228         unwsec = sec;
9229     }
9230
9231   if (unwsec == NULL)
9232     printf (_("\nThere are no unwind sections in this file.\n"));
9233   else
9234     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9235       {
9236         if (sec->sh_type == sec_type)
9237           {
9238             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9239             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9240                               "contains %lu entry:\n",
9241                               "\nUnwind section '%s' at offset 0x%lx "
9242                               "contains %lu entries:\n",
9243                               num_unwind),
9244                     printable_section_name (filedata, sec),
9245                     (unsigned long) sec->sh_offset,
9246                     num_unwind);
9247
9248             if (! dump_arm_unwind (filedata, &aux, sec))
9249               res = FALSE;
9250           }
9251       }
9252
9253   if (aux.symtab)
9254     free (aux.symtab);
9255   if (aux.strtab)
9256     free ((char *) aux.strtab);
9257
9258   return res;
9259 }
9260
9261 static bfd_boolean
9262 process_unwind (Filedata * filedata)
9263 {
9264   struct unwind_handler
9265   {
9266     unsigned int machtype;
9267     bfd_boolean (* handler)(Filedata *);
9268   } handlers[] =
9269   {
9270     { EM_ARM, arm_process_unwind },
9271     { EM_IA_64, ia64_process_unwind },
9272     { EM_PARISC, hppa_process_unwind },
9273     { EM_TI_C6000, arm_process_unwind },
9274     { 0, NULL }
9275   };
9276   int i;
9277
9278   if (!do_unwind)
9279     return TRUE;
9280
9281   for (i = 0; handlers[i].handler != NULL; i++)
9282     if (filedata->file_header.e_machine == handlers[i].machtype)
9283       return handlers[i].handler (filedata);
9284
9285   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9286           get_machine_name (filedata->file_header.e_machine));
9287   return TRUE;
9288 }
9289
9290 static void
9291 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9292 {
9293   switch (entry->d_tag)
9294     {
9295     case DT_MIPS_FLAGS:
9296       if (entry->d_un.d_val == 0)
9297         printf (_("NONE"));
9298       else
9299         {
9300           static const char * opts[] =
9301           {
9302             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9303             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9304             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9305             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9306             "RLD_ORDER_SAFE"
9307           };
9308           unsigned int cnt;
9309           bfd_boolean first = TRUE;
9310
9311           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9312             if (entry->d_un.d_val & (1 << cnt))
9313               {
9314                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9315                 first = FALSE;
9316               }
9317         }
9318       break;
9319
9320     case DT_MIPS_IVERSION:
9321       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9322         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9323       else
9324         {
9325           char buf[40];
9326           sprintf_vma (buf, entry->d_un.d_ptr);
9327           /* Note: coded this way so that there is a single string for translation.  */
9328           printf (_("<corrupt: %s>"), buf);
9329         }
9330       break;
9331
9332     case DT_MIPS_TIME_STAMP:
9333       {
9334         char timebuf[128];
9335         struct tm * tmp;
9336         time_t atime = entry->d_un.d_val;
9337
9338         tmp = gmtime (&atime);
9339         /* PR 17531: file: 6accc532.  */
9340         if (tmp == NULL)
9341           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9342         else
9343           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9344                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9345                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9346         printf (_("Time Stamp: %s"), timebuf);
9347       }
9348       break;
9349
9350     case DT_MIPS_RLD_VERSION:
9351     case DT_MIPS_LOCAL_GOTNO:
9352     case DT_MIPS_CONFLICTNO:
9353     case DT_MIPS_LIBLISTNO:
9354     case DT_MIPS_SYMTABNO:
9355     case DT_MIPS_UNREFEXTNO:
9356     case DT_MIPS_HIPAGENO:
9357     case DT_MIPS_DELTA_CLASS_NO:
9358     case DT_MIPS_DELTA_INSTANCE_NO:
9359     case DT_MIPS_DELTA_RELOC_NO:
9360     case DT_MIPS_DELTA_SYM_NO:
9361     case DT_MIPS_DELTA_CLASSSYM_NO:
9362     case DT_MIPS_COMPACT_SIZE:
9363       print_vma (entry->d_un.d_val, DEC);
9364       break;
9365
9366     default:
9367       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9368     }
9369     putchar ('\n');
9370 }
9371
9372 static void
9373 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9374 {
9375   switch (entry->d_tag)
9376     {
9377     case DT_HP_DLD_FLAGS:
9378       {
9379         static struct
9380         {
9381           long int bit;
9382           const char * str;
9383         }
9384         flags[] =
9385         {
9386           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9387           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9388           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9389           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9390           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9391           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9392           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9393           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9394           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9395           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9396           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9397           { DT_HP_GST, "HP_GST" },
9398           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9399           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9400           { DT_HP_NODELETE, "HP_NODELETE" },
9401           { DT_HP_GROUP, "HP_GROUP" },
9402           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9403         };
9404         bfd_boolean first = TRUE;
9405         size_t cnt;
9406         bfd_vma val = entry->d_un.d_val;
9407
9408         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9409           if (val & flags[cnt].bit)
9410             {
9411               if (! first)
9412                 putchar (' ');
9413               fputs (flags[cnt].str, stdout);
9414               first = FALSE;
9415               val ^= flags[cnt].bit;
9416             }
9417
9418         if (val != 0 || first)
9419           {
9420             if (! first)
9421               putchar (' ');
9422             print_vma (val, HEX);
9423           }
9424       }
9425       break;
9426
9427     default:
9428       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9429       break;
9430     }
9431   putchar ('\n');
9432 }
9433
9434 #ifdef BFD64
9435
9436 /* VMS vs Unix time offset and factor.  */
9437
9438 #define VMS_EPOCH_OFFSET 35067168000000000LL
9439 #define VMS_GRANULARITY_FACTOR 10000000
9440
9441 /* Display a VMS time in a human readable format.  */
9442
9443 static void
9444 print_vms_time (bfd_int64_t vmstime)
9445 {
9446   struct tm *tm;
9447   time_t unxtime;
9448
9449   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9450   tm = gmtime (&unxtime);
9451   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9452           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9453           tm->tm_hour, tm->tm_min, tm->tm_sec);
9454 }
9455 #endif /* BFD64 */
9456
9457 static void
9458 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9459 {
9460   switch (entry->d_tag)
9461     {
9462     case DT_IA_64_PLT_RESERVE:
9463       /* First 3 slots reserved.  */
9464       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9465       printf (" -- ");
9466       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9467       break;
9468
9469     case DT_IA_64_VMS_LINKTIME:
9470 #ifdef BFD64
9471       print_vms_time (entry->d_un.d_val);
9472 #endif
9473       break;
9474
9475     case DT_IA_64_VMS_LNKFLAGS:
9476       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9477       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9478         printf (" CALL_DEBUG");
9479       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9480         printf (" NOP0BUFS");
9481       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9482         printf (" P0IMAGE");
9483       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9484         printf (" MKTHREADS");
9485       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9486         printf (" UPCALLS");
9487       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9488         printf (" IMGSTA");
9489       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9490         printf (" INITIALIZE");
9491       if (entry->d_un.d_val & VMS_LF_MAIN)
9492         printf (" MAIN");
9493       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9494         printf (" EXE_INIT");
9495       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9496         printf (" TBK_IN_IMG");
9497       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9498         printf (" DBG_IN_IMG");
9499       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9500         printf (" TBK_IN_DSF");
9501       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9502         printf (" DBG_IN_DSF");
9503       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9504         printf (" SIGNATURES");
9505       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9506         printf (" REL_SEG_OFF");
9507       break;
9508
9509     default:
9510       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9511       break;
9512     }
9513   putchar ('\n');
9514 }
9515
9516 static bfd_boolean
9517 get_32bit_dynamic_section (Filedata * filedata)
9518 {
9519   Elf32_External_Dyn * edyn;
9520   Elf32_External_Dyn * ext;
9521   Elf_Internal_Dyn * entry;
9522
9523   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9524                                           dynamic_size, _("dynamic section"));
9525   if (!edyn)
9526     return FALSE;
9527
9528   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9529      might not have the luxury of section headers.  Look for the DT_NULL
9530      terminator to determine the number of entries.  */
9531   for (ext = edyn, dynamic_nent = 0;
9532        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9533        ext++)
9534     {
9535       dynamic_nent++;
9536       if (BYTE_GET (ext->d_tag) == DT_NULL)
9537         break;
9538     }
9539
9540   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9541                                                   sizeof (* entry));
9542   if (dynamic_section == NULL)
9543     {
9544       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9545              (unsigned long) dynamic_nent);
9546       free (edyn);
9547       return FALSE;
9548     }
9549
9550   for (ext = edyn, entry = dynamic_section;
9551        entry < dynamic_section + dynamic_nent;
9552        ext++, entry++)
9553     {
9554       entry->d_tag      = BYTE_GET (ext->d_tag);
9555       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9556     }
9557
9558   free (edyn);
9559
9560   return TRUE;
9561 }
9562
9563 static bfd_boolean
9564 get_64bit_dynamic_section (Filedata * filedata)
9565 {
9566   Elf64_External_Dyn * edyn;
9567   Elf64_External_Dyn * ext;
9568   Elf_Internal_Dyn * entry;
9569
9570   /* Read in the data.  */
9571   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9572                                           dynamic_size, _("dynamic section"));
9573   if (!edyn)
9574     return FALSE;
9575
9576   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9577      might not have the luxury of section headers.  Look for the DT_NULL
9578      terminator to determine the number of entries.  */
9579   for (ext = edyn, dynamic_nent = 0;
9580        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9581        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9582        ext++)
9583     {
9584       dynamic_nent++;
9585       if (BYTE_GET (ext->d_tag) == DT_NULL)
9586         break;
9587     }
9588
9589   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9590                                                   sizeof (* entry));
9591   if (dynamic_section == NULL)
9592     {
9593       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9594              (unsigned long) dynamic_nent);
9595       free (edyn);
9596       return FALSE;
9597     }
9598
9599   /* Convert from external to internal formats.  */
9600   for (ext = edyn, entry = dynamic_section;
9601        entry < dynamic_section + dynamic_nent;
9602        ext++, entry++)
9603     {
9604       entry->d_tag      = BYTE_GET (ext->d_tag);
9605       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9606     }
9607
9608   free (edyn);
9609
9610   return TRUE;
9611 }
9612
9613 static void
9614 print_dynamic_flags (bfd_vma flags)
9615 {
9616   bfd_boolean first = TRUE;
9617
9618   while (flags)
9619     {
9620       bfd_vma flag;
9621
9622       flag = flags & - flags;
9623       flags &= ~ flag;
9624
9625       if (first)
9626         first = FALSE;
9627       else
9628         putc (' ', stdout);
9629
9630       switch (flag)
9631         {
9632         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9633         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9634         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9635         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9636         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9637         default:                fputs (_("unknown"), stdout); break;
9638         }
9639     }
9640   puts ("");
9641 }
9642
9643 /* Parse and display the contents of the dynamic section.  */
9644
9645 static bfd_boolean
9646 process_dynamic_section (Filedata * filedata)
9647 {
9648   Elf_Internal_Dyn * entry;
9649
9650   if (dynamic_size == 0)
9651     {
9652       if (do_dynamic)
9653         printf (_("\nThere is no dynamic section in this file.\n"));
9654
9655       return TRUE;
9656     }
9657
9658   if (is_32bit_elf)
9659     {
9660       if (! get_32bit_dynamic_section (filedata))
9661         return FALSE;
9662     }
9663   else
9664     {
9665       if (! get_64bit_dynamic_section (filedata))
9666         return FALSE;
9667     }
9668
9669   /* Find the appropriate symbol table.  */
9670   if (dynamic_symbols == NULL)
9671     {
9672       for (entry = dynamic_section;
9673            entry < dynamic_section + dynamic_nent;
9674            ++entry)
9675         {
9676           Elf_Internal_Shdr section;
9677
9678           if (entry->d_tag != DT_SYMTAB)
9679             continue;
9680
9681           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9682
9683           /* Since we do not know how big the symbol table is,
9684              we default to reading in the entire file (!) and
9685              processing that.  This is overkill, I know, but it
9686              should work.  */
9687           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9688           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9689             {
9690               /* See PR 21379 for a reproducer.  */
9691               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9692               return FALSE;
9693             }
9694
9695           if (archive_file_offset != 0)
9696             section.sh_size = archive_file_size - section.sh_offset;
9697           else
9698             section.sh_size = filedata->file_size - section.sh_offset;
9699
9700           if (is_32bit_elf)
9701             section.sh_entsize = sizeof (Elf32_External_Sym);
9702           else
9703             section.sh_entsize = sizeof (Elf64_External_Sym);
9704           section.sh_name = filedata->string_table_length;
9705
9706           if (dynamic_symbols != NULL)
9707             {
9708               error (_("Multiple dynamic symbol table sections found\n"));
9709               free (dynamic_symbols);
9710             }
9711           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9712           if (num_dynamic_syms < 1)
9713             {
9714               error (_("Unable to determine the number of symbols to load\n"));
9715               continue;
9716             }
9717         }
9718     }
9719
9720   /* Similarly find a string table.  */
9721   if (dynamic_strings == NULL)
9722     {
9723       for (entry = dynamic_section;
9724            entry < dynamic_section + dynamic_nent;
9725            ++entry)
9726         {
9727           unsigned long offset;
9728           long str_tab_len;
9729
9730           if (entry->d_tag != DT_STRTAB)
9731             continue;
9732
9733           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9734
9735           /* Since we do not know how big the string table is,
9736              we default to reading in the entire file (!) and
9737              processing that.  This is overkill, I know, but it
9738              should work.  */
9739
9740           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9741
9742           if (archive_file_offset != 0)
9743             str_tab_len = archive_file_size - offset;
9744           else
9745             str_tab_len = filedata->file_size - offset;
9746
9747           if (str_tab_len < 1)
9748             {
9749               error
9750                 (_("Unable to determine the length of the dynamic string table\n"));
9751               continue;
9752             }
9753
9754           if (dynamic_strings != NULL)
9755             {
9756               error (_("Multiple dynamic string tables found\n"));
9757               free (dynamic_strings);
9758             }
9759
9760           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9761                                                str_tab_len,
9762                                                _("dynamic string table"));
9763           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9764         }
9765     }
9766
9767   /* And find the syminfo section if available.  */
9768   if (dynamic_syminfo == NULL)
9769     {
9770       unsigned long syminsz = 0;
9771
9772       for (entry = dynamic_section;
9773            entry < dynamic_section + dynamic_nent;
9774            ++entry)
9775         {
9776           if (entry->d_tag == DT_SYMINENT)
9777             {
9778               /* Note: these braces are necessary to avoid a syntax
9779                  error from the SunOS4 C compiler.  */
9780               /* PR binutils/17531: A corrupt file can trigger this test.
9781                  So do not use an assert, instead generate an error message.  */
9782               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9783                 error (_("Bad value (%d) for SYMINENT entry\n"),
9784                        (int) entry->d_un.d_val);
9785             }
9786           else if (entry->d_tag == DT_SYMINSZ)
9787             syminsz = entry->d_un.d_val;
9788           else if (entry->d_tag == DT_SYMINFO)
9789             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9790                                                       syminsz);
9791         }
9792
9793       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9794         {
9795           Elf_External_Syminfo * extsyminfo;
9796           Elf_External_Syminfo * extsym;
9797           Elf_Internal_Syminfo * syminfo;
9798
9799           /* There is a syminfo section.  Read the data.  */
9800           extsyminfo = (Elf_External_Syminfo *)
9801               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9802                         _("symbol information"));
9803           if (!extsyminfo)
9804             return FALSE;
9805
9806           if (dynamic_syminfo != NULL)
9807             {
9808               error (_("Multiple dynamic symbol information sections found\n"));
9809               free (dynamic_syminfo);
9810             }
9811           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9812           if (dynamic_syminfo == NULL)
9813             {
9814               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9815                      (unsigned long) syminsz);
9816               return FALSE;
9817             }
9818
9819           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9820           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9821                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9822                ++syminfo, ++extsym)
9823             {
9824               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9825               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9826             }
9827
9828           free (extsyminfo);
9829         }
9830     }
9831
9832   if (do_dynamic && dynamic_addr)
9833     printf (ngettext ("\nDynamic section at offset 0x%lx "
9834                       "contains %lu entry:\n",
9835                       "\nDynamic section at offset 0x%lx "
9836                       "contains %lu entries:\n",
9837                       dynamic_nent),
9838             dynamic_addr, (unsigned long) dynamic_nent);
9839   if (do_dynamic)
9840     printf (_("  Tag        Type                         Name/Value\n"));
9841
9842   for (entry = dynamic_section;
9843        entry < dynamic_section + dynamic_nent;
9844        entry++)
9845     {
9846       if (do_dynamic)
9847         {
9848           const char * dtype;
9849
9850           putchar (' ');
9851           print_vma (entry->d_tag, FULL_HEX);
9852           dtype = get_dynamic_type (filedata, entry->d_tag);
9853           printf (" (%s)%*s", dtype,
9854                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9855         }
9856
9857       switch (entry->d_tag)
9858         {
9859         case DT_FLAGS:
9860           if (do_dynamic)
9861             print_dynamic_flags (entry->d_un.d_val);
9862           break;
9863
9864         case DT_AUXILIARY:
9865         case DT_FILTER:
9866         case DT_CONFIG:
9867         case DT_DEPAUDIT:
9868         case DT_AUDIT:
9869           if (do_dynamic)
9870             {
9871               switch (entry->d_tag)
9872                 {
9873                 case DT_AUXILIARY:
9874                   printf (_("Auxiliary library"));
9875                   break;
9876
9877                 case DT_FILTER:
9878                   printf (_("Filter library"));
9879                   break;
9880
9881                 case DT_CONFIG:
9882                   printf (_("Configuration file"));
9883                   break;
9884
9885                 case DT_DEPAUDIT:
9886                   printf (_("Dependency audit library"));
9887                   break;
9888
9889                 case DT_AUDIT:
9890                   printf (_("Audit library"));
9891                   break;
9892                 }
9893
9894               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9895                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9896               else
9897                 {
9898                   printf (": ");
9899                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9900                   putchar ('\n');
9901                 }
9902             }
9903           break;
9904
9905         case DT_FEATURE:
9906           if (do_dynamic)
9907             {
9908               printf (_("Flags:"));
9909
9910               if (entry->d_un.d_val == 0)
9911                 printf (_(" None\n"));
9912               else
9913                 {
9914                   unsigned long int val = entry->d_un.d_val;
9915
9916                   if (val & DTF_1_PARINIT)
9917                     {
9918                       printf (" PARINIT");
9919                       val ^= DTF_1_PARINIT;
9920                     }
9921                   if (val & DTF_1_CONFEXP)
9922                     {
9923                       printf (" CONFEXP");
9924                       val ^= DTF_1_CONFEXP;
9925                     }
9926                   if (val != 0)
9927                     printf (" %lx", val);
9928                   puts ("");
9929                 }
9930             }
9931           break;
9932
9933         case DT_POSFLAG_1:
9934           if (do_dynamic)
9935             {
9936               printf (_("Flags:"));
9937
9938               if (entry->d_un.d_val == 0)
9939                 printf (_(" None\n"));
9940               else
9941                 {
9942                   unsigned long int val = entry->d_un.d_val;
9943
9944                   if (val & DF_P1_LAZYLOAD)
9945                     {
9946                       printf (" LAZYLOAD");
9947                       val ^= DF_P1_LAZYLOAD;
9948                     }
9949                   if (val & DF_P1_GROUPPERM)
9950                     {
9951                       printf (" GROUPPERM");
9952                       val ^= DF_P1_GROUPPERM;
9953                     }
9954                   if (val != 0)
9955                     printf (" %lx", val);
9956                   puts ("");
9957                 }
9958             }
9959           break;
9960
9961         case DT_FLAGS_1:
9962           if (do_dynamic)
9963             {
9964               printf (_("Flags:"));
9965               if (entry->d_un.d_val == 0)
9966                 printf (_(" None\n"));
9967               else
9968                 {
9969                   unsigned long int val = entry->d_un.d_val;
9970
9971                   if (val & DF_1_NOW)
9972                     {
9973                       printf (" NOW");
9974                       val ^= DF_1_NOW;
9975                     }
9976                   if (val & DF_1_GLOBAL)
9977                     {
9978                       printf (" GLOBAL");
9979                       val ^= DF_1_GLOBAL;
9980                     }
9981                   if (val & DF_1_GROUP)
9982                     {
9983                       printf (" GROUP");
9984                       val ^= DF_1_GROUP;
9985                     }
9986                   if (val & DF_1_NODELETE)
9987                     {
9988                       printf (" NODELETE");
9989                       val ^= DF_1_NODELETE;
9990                     }
9991                   if (val & DF_1_LOADFLTR)
9992                     {
9993                       printf (" LOADFLTR");
9994                       val ^= DF_1_LOADFLTR;
9995                     }
9996                   if (val & DF_1_INITFIRST)
9997                     {
9998                       printf (" INITFIRST");
9999                       val ^= DF_1_INITFIRST;
10000                     }
10001                   if (val & DF_1_NOOPEN)
10002                     {
10003                       printf (" NOOPEN");
10004                       val ^= DF_1_NOOPEN;
10005                     }
10006                   if (val & DF_1_ORIGIN)
10007                     {
10008                       printf (" ORIGIN");
10009                       val ^= DF_1_ORIGIN;
10010                     }
10011                   if (val & DF_1_DIRECT)
10012                     {
10013                       printf (" DIRECT");
10014                       val ^= DF_1_DIRECT;
10015                     }
10016                   if (val & DF_1_TRANS)
10017                     {
10018                       printf (" TRANS");
10019                       val ^= DF_1_TRANS;
10020                     }
10021                   if (val & DF_1_INTERPOSE)
10022                     {
10023                       printf (" INTERPOSE");
10024                       val ^= DF_1_INTERPOSE;
10025                     }
10026                   if (val & DF_1_NODEFLIB)
10027                     {
10028                       printf (" NODEFLIB");
10029                       val ^= DF_1_NODEFLIB;
10030                     }
10031                   if (val & DF_1_NODUMP)
10032                     {
10033                       printf (" NODUMP");
10034                       val ^= DF_1_NODUMP;
10035                     }
10036                   if (val & DF_1_CONFALT)
10037                     {
10038                       printf (" CONFALT");
10039                       val ^= DF_1_CONFALT;
10040                     }
10041                   if (val & DF_1_ENDFILTEE)
10042                     {
10043                       printf (" ENDFILTEE");
10044                       val ^= DF_1_ENDFILTEE;
10045                     }
10046                   if (val & DF_1_DISPRELDNE)
10047                     {
10048                       printf (" DISPRELDNE");
10049                       val ^= DF_1_DISPRELDNE;
10050                     }
10051                   if (val & DF_1_DISPRELPND)
10052                     {
10053                       printf (" DISPRELPND");
10054                       val ^= DF_1_DISPRELPND;
10055                     }
10056                   if (val & DF_1_NODIRECT)
10057                     {
10058                       printf (" NODIRECT");
10059                       val ^= DF_1_NODIRECT;
10060                     }
10061                   if (val & DF_1_IGNMULDEF)
10062                     {
10063                       printf (" IGNMULDEF");
10064                       val ^= DF_1_IGNMULDEF;
10065                     }
10066                   if (val & DF_1_NOKSYMS)
10067                     {
10068                       printf (" NOKSYMS");
10069                       val ^= DF_1_NOKSYMS;
10070                     }
10071                   if (val & DF_1_NOHDR)
10072                     {
10073                       printf (" NOHDR");
10074                       val ^= DF_1_NOHDR;
10075                     }
10076                   if (val & DF_1_EDITED)
10077                     {
10078                       printf (" EDITED");
10079                       val ^= DF_1_EDITED;
10080                     }
10081                   if (val & DF_1_NORELOC)
10082                     {
10083                       printf (" NORELOC");
10084                       val ^= DF_1_NORELOC;
10085                     }
10086                   if (val & DF_1_SYMINTPOSE)
10087                     {
10088                       printf (" SYMINTPOSE");
10089                       val ^= DF_1_SYMINTPOSE;
10090                     }
10091                   if (val & DF_1_GLOBAUDIT)
10092                     {
10093                       printf (" GLOBAUDIT");
10094                       val ^= DF_1_GLOBAUDIT;
10095                     }
10096                   if (val & DF_1_SINGLETON)
10097                     {
10098                       printf (" SINGLETON");
10099                       val ^= DF_1_SINGLETON;
10100                     }
10101                   if (val & DF_1_STUB)
10102                     {
10103                       printf (" STUB");
10104                       val ^= DF_1_STUB;
10105                     }
10106                   if (val & DF_1_PIE)
10107                     {
10108                       printf (" PIE");
10109                       val ^= DF_1_PIE;
10110                     }
10111                   if (val & DF_1_KMOD)
10112                     {
10113                       printf (" KMOD");
10114                       val ^= DF_1_KMOD;
10115                     }
10116                   if (val & DF_1_WEAKFILTER)
10117                     {
10118                       printf (" WEAKFILTER");
10119                       val ^= DF_1_WEAKFILTER;
10120                     }
10121                   if (val & DF_1_NOCOMMON)
10122                     {
10123                       printf (" NOCOMMON");
10124                       val ^= DF_1_NOCOMMON;
10125                     }
10126                   if (val != 0)
10127                     printf (" %lx", val);
10128                   puts ("");
10129                 }
10130             }
10131           break;
10132
10133         case DT_PLTREL:
10134           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10135           if (do_dynamic)
10136             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10137           break;
10138
10139         case DT_NULL    :
10140         case DT_NEEDED  :
10141         case DT_PLTGOT  :
10142         case DT_HASH    :
10143         case DT_STRTAB  :
10144         case DT_SYMTAB  :
10145         case DT_RELA    :
10146         case DT_INIT    :
10147         case DT_FINI    :
10148         case DT_SONAME  :
10149         case DT_RPATH   :
10150         case DT_SYMBOLIC:
10151         case DT_REL     :
10152         case DT_DEBUG   :
10153         case DT_TEXTREL :
10154         case DT_JMPREL  :
10155         case DT_RUNPATH :
10156           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10157
10158           if (do_dynamic)
10159             {
10160               char * name;
10161
10162               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10163                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10164               else
10165                 name = NULL;
10166
10167               if (name)
10168                 {
10169                   switch (entry->d_tag)
10170                     {
10171                     case DT_NEEDED:
10172                       printf (_("Shared library: [%s]"), name);
10173
10174                       if (streq (name, program_interpreter))
10175                         printf (_(" program interpreter"));
10176                       break;
10177
10178                     case DT_SONAME:
10179                       printf (_("Library soname: [%s]"), name);
10180                       break;
10181
10182                     case DT_RPATH:
10183                       printf (_("Library rpath: [%s]"), name);
10184                       break;
10185
10186                     case DT_RUNPATH:
10187                       printf (_("Library runpath: [%s]"), name);
10188                       break;
10189
10190                     default:
10191                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10192                       break;
10193                     }
10194                 }
10195               else
10196                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10197
10198               putchar ('\n');
10199             }
10200           break;
10201
10202         case DT_PLTRELSZ:
10203         case DT_RELASZ  :
10204         case DT_STRSZ   :
10205         case DT_RELSZ   :
10206         case DT_RELAENT :
10207         case DT_SYMENT  :
10208         case DT_RELENT  :
10209           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10210           /* Fall through.  */
10211         case DT_PLTPADSZ:
10212         case DT_MOVEENT :
10213         case DT_MOVESZ  :
10214         case DT_INIT_ARRAYSZ:
10215         case DT_FINI_ARRAYSZ:
10216         case DT_GNU_CONFLICTSZ:
10217         case DT_GNU_LIBLISTSZ:
10218           if (do_dynamic)
10219             {
10220               print_vma (entry->d_un.d_val, UNSIGNED);
10221               printf (_(" (bytes)\n"));
10222             }
10223           break;
10224
10225         case DT_VERDEFNUM:
10226         case DT_VERNEEDNUM:
10227         case DT_RELACOUNT:
10228         case DT_RELCOUNT:
10229           if (do_dynamic)
10230             {
10231               print_vma (entry->d_un.d_val, UNSIGNED);
10232               putchar ('\n');
10233             }
10234           break;
10235
10236         case DT_SYMINSZ:
10237         case DT_SYMINENT:
10238         case DT_SYMINFO:
10239         case DT_USED:
10240         case DT_INIT_ARRAY:
10241         case DT_FINI_ARRAY:
10242           if (do_dynamic)
10243             {
10244               if (entry->d_tag == DT_USED
10245                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10246                 {
10247                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10248
10249                   if (*name)
10250                     {
10251                       printf (_("Not needed object: [%s]\n"), name);
10252                       break;
10253                     }
10254                 }
10255
10256               print_vma (entry->d_un.d_val, PREFIX_HEX);
10257               putchar ('\n');
10258             }
10259           break;
10260
10261         case DT_BIND_NOW:
10262           /* The value of this entry is ignored.  */
10263           if (do_dynamic)
10264             putchar ('\n');
10265           break;
10266
10267         case DT_GNU_PRELINKED:
10268           if (do_dynamic)
10269             {
10270               struct tm * tmp;
10271               time_t atime = entry->d_un.d_val;
10272
10273               tmp = gmtime (&atime);
10274               /* PR 17533 file: 041-1244816-0.004.  */
10275               if (tmp == NULL)
10276                 printf (_("<corrupt time val: %lx"),
10277                         (unsigned long) atime);
10278               else
10279                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10280                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10281                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10282
10283             }
10284           break;
10285
10286         case DT_GNU_HASH:
10287           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10288           if (do_dynamic)
10289             {
10290               print_vma (entry->d_un.d_val, PREFIX_HEX);
10291               putchar ('\n');
10292             }
10293           break;
10294
10295         default:
10296           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10297             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10298               entry->d_un.d_val;
10299
10300           if (do_dynamic)
10301             {
10302               switch (filedata->file_header.e_machine)
10303                 {
10304                 case EM_MIPS:
10305                 case EM_MIPS_RS3_LE:
10306                   dynamic_section_mips_val (entry);
10307                   break;
10308                 case EM_PARISC:
10309                   dynamic_section_parisc_val (entry);
10310                   break;
10311                 case EM_IA_64:
10312                   dynamic_section_ia64_val (entry);
10313                   break;
10314                 default:
10315                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10316                   putchar ('\n');
10317                 }
10318             }
10319           break;
10320         }
10321     }
10322
10323   return TRUE;
10324 }
10325
10326 static char *
10327 get_ver_flags (unsigned int flags)
10328 {
10329   static char buff[128];
10330
10331   buff[0] = 0;
10332
10333   if (flags == 0)
10334     return _("none");
10335
10336   if (flags & VER_FLG_BASE)
10337     strcat (buff, "BASE");
10338
10339   if (flags & VER_FLG_WEAK)
10340     {
10341       if (flags & VER_FLG_BASE)
10342         strcat (buff, " | ");
10343
10344       strcat (buff, "WEAK");
10345     }
10346
10347   if (flags & VER_FLG_INFO)
10348     {
10349       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10350         strcat (buff, " | ");
10351
10352       strcat (buff, "INFO");
10353     }
10354
10355   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10356     {
10357       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10358         strcat (buff, " | ");
10359
10360       strcat (buff, _("<unknown>"));
10361     }
10362
10363   return buff;
10364 }
10365
10366 /* Display the contents of the version sections.  */
10367
10368 static bfd_boolean
10369 process_version_sections (Filedata * filedata)
10370 {
10371   Elf_Internal_Shdr * section;
10372   unsigned i;
10373   bfd_boolean found = FALSE;
10374
10375   if (! do_version)
10376     return TRUE;
10377
10378   for (i = 0, section = filedata->section_headers;
10379        i < filedata->file_header.e_shnum;
10380        i++, section++)
10381     {
10382       switch (section->sh_type)
10383         {
10384         case SHT_GNU_verdef:
10385           {
10386             Elf_External_Verdef * edefs;
10387             unsigned long idx;
10388             unsigned long cnt;
10389             char * endbuf;
10390
10391             found = TRUE;
10392
10393             printf (ngettext ("\nVersion definition section '%s' "
10394                               "contains %u entry:\n",
10395                               "\nVersion definition section '%s' "
10396                               "contains %u entries:\n",
10397                               section->sh_info),
10398                     printable_section_name (filedata, section),
10399                     section->sh_info);
10400
10401             printf (_("  Addr: 0x"));
10402             printf_vma (section->sh_addr);
10403             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10404                     (unsigned long) section->sh_offset, section->sh_link,
10405                     printable_section_name_from_index (filedata, section->sh_link));
10406
10407             edefs = (Elf_External_Verdef *)
10408                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10409                           _("version definition section"));
10410             if (!edefs)
10411               break;
10412             endbuf = (char *) edefs + section->sh_size;
10413
10414             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10415               {
10416                 char * vstart;
10417                 Elf_External_Verdef * edef;
10418                 Elf_Internal_Verdef ent;
10419                 Elf_External_Verdaux * eaux;
10420                 Elf_Internal_Verdaux aux;
10421                 unsigned long isum;
10422                 int j;
10423
10424                 vstart = ((char *) edefs) + idx;
10425                 if (vstart + sizeof (*edef) > endbuf)
10426                   break;
10427
10428                 edef = (Elf_External_Verdef *) vstart;
10429
10430                 ent.vd_version = BYTE_GET (edef->vd_version);
10431                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10432                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10433                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10434                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10435                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10436                 ent.vd_next    = BYTE_GET (edef->vd_next);
10437
10438                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10439                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10440
10441                 printf (_("  Index: %d  Cnt: %d  "),
10442                         ent.vd_ndx, ent.vd_cnt);
10443
10444                 /* Check for overflow.  */
10445                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10446                   break;
10447
10448                 vstart += ent.vd_aux;
10449
10450                 if (vstart + sizeof (*eaux) > endbuf)
10451                   break;
10452                 eaux = (Elf_External_Verdaux *) vstart;
10453
10454                 aux.vda_name = BYTE_GET (eaux->vda_name);
10455                 aux.vda_next = BYTE_GET (eaux->vda_next);
10456
10457                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10458                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10459                 else
10460                   printf (_("Name index: %ld\n"), aux.vda_name);
10461
10462                 isum = idx + ent.vd_aux;
10463
10464                 for (j = 1; j < ent.vd_cnt; j++)
10465                   {
10466                     if (aux.vda_next < sizeof (*eaux)
10467                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10468                       {
10469                         warn (_("Invalid vda_next field of %lx\n"),
10470                               aux.vda_next);
10471                         j = ent.vd_cnt;
10472                         break;
10473                       }
10474                     /* Check for overflow.  */
10475                     if (aux.vda_next > (size_t) (endbuf - vstart))
10476                       break;
10477
10478                     isum   += aux.vda_next;
10479                     vstart += aux.vda_next;
10480
10481                     if (vstart + sizeof (*eaux) > endbuf)
10482                       break;
10483                     eaux = (Elf_External_Verdaux *) vstart;
10484
10485                     aux.vda_name = BYTE_GET (eaux->vda_name);
10486                     aux.vda_next = BYTE_GET (eaux->vda_next);
10487
10488                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10489                       printf (_("  %#06lx: Parent %d: %s\n"),
10490                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10491                     else
10492                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10493                               isum, j, aux.vda_name);
10494                   }
10495
10496                 if (j < ent.vd_cnt)
10497                   printf (_("  Version def aux past end of section\n"));
10498
10499                 /* PR 17531:
10500                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10501                 if (ent.vd_next < sizeof (*edef)
10502                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10503                   {
10504                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10505                     cnt = section->sh_info;
10506                     break;
10507                   }
10508                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10509                   break;
10510
10511                 idx += ent.vd_next;
10512               }
10513
10514             if (cnt < section->sh_info)
10515               printf (_("  Version definition past end of section\n"));
10516
10517             free (edefs);
10518           }
10519           break;
10520
10521         case SHT_GNU_verneed:
10522           {
10523             Elf_External_Verneed * eneed;
10524             unsigned long idx;
10525             unsigned long cnt;
10526             char * endbuf;
10527
10528             found = TRUE;
10529
10530             printf (ngettext ("\nVersion needs section '%s' "
10531                               "contains %u entry:\n",
10532                               "\nVersion needs section '%s' "
10533                               "contains %u entries:\n",
10534                               section->sh_info),
10535                     printable_section_name (filedata, section), section->sh_info);
10536
10537             printf (_(" Addr: 0x"));
10538             printf_vma (section->sh_addr);
10539             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10540                     (unsigned long) section->sh_offset, section->sh_link,
10541                     printable_section_name_from_index (filedata, section->sh_link));
10542
10543             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10544                                                        section->sh_offset, 1,
10545                                                        section->sh_size,
10546                                                        _("Version Needs section"));
10547             if (!eneed)
10548               break;
10549             endbuf = (char *) eneed + section->sh_size;
10550
10551             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10552               {
10553                 Elf_External_Verneed * entry;
10554                 Elf_Internal_Verneed ent;
10555                 unsigned long isum;
10556                 int j;
10557                 char * vstart;
10558
10559                 vstart = ((char *) eneed) + idx;
10560                 if (vstart + sizeof (*entry) > endbuf)
10561                   break;
10562
10563                 entry = (Elf_External_Verneed *) vstart;
10564
10565                 ent.vn_version = BYTE_GET (entry->vn_version);
10566                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10567                 ent.vn_file    = BYTE_GET (entry->vn_file);
10568                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10569                 ent.vn_next    = BYTE_GET (entry->vn_next);
10570
10571                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10572
10573                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10574                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10575                 else
10576                   printf (_("  File: %lx"), ent.vn_file);
10577
10578                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10579
10580                 /* Check for overflow.  */
10581                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10582                   break;
10583                 vstart += ent.vn_aux;
10584
10585                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10586                   {
10587                     Elf_External_Vernaux * eaux;
10588                     Elf_Internal_Vernaux aux;
10589
10590                     if (vstart + sizeof (*eaux) > endbuf)
10591                       break;
10592                     eaux = (Elf_External_Vernaux *) vstart;
10593
10594                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10595                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10596                     aux.vna_other = BYTE_GET (eaux->vna_other);
10597                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10598                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10599
10600                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10601                       printf (_("  %#06lx:   Name: %s"),
10602                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10603                     else
10604                       printf (_("  %#06lx:   Name index: %lx"),
10605                               isum, aux.vna_name);
10606
10607                     printf (_("  Flags: %s  Version: %d\n"),
10608                             get_ver_flags (aux.vna_flags), aux.vna_other);
10609
10610                     if (aux.vna_next < sizeof (*eaux)
10611                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10612                       {
10613                         warn (_("Invalid vna_next field of %lx\n"),
10614                               aux.vna_next);
10615                         j = ent.vn_cnt;
10616                         break;
10617                       }
10618                     /* Check for overflow.  */
10619                     if (aux.vna_next > (size_t) (endbuf - vstart))
10620                       break;
10621                     isum   += aux.vna_next;
10622                     vstart += aux.vna_next;
10623                   }
10624
10625                 if (j < ent.vn_cnt)
10626                   warn (_("Missing Version Needs auxillary information\n"));
10627
10628                 if (ent.vn_next < sizeof (*entry)
10629                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10630                   {
10631                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10632                     cnt = section->sh_info;
10633                     break;
10634                   }
10635                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10636                   break;
10637                 idx += ent.vn_next;
10638               }
10639
10640             if (cnt < section->sh_info)
10641               warn (_("Missing Version Needs information\n"));
10642
10643             free (eneed);
10644           }
10645           break;
10646
10647         case SHT_GNU_versym:
10648           {
10649             Elf_Internal_Shdr * link_section;
10650             size_t total;
10651             unsigned int cnt;
10652             unsigned char * edata;
10653             unsigned short * data;
10654             char * strtab;
10655             Elf_Internal_Sym * symbols;
10656             Elf_Internal_Shdr * string_sec;
10657             unsigned long num_syms;
10658             long off;
10659
10660             if (section->sh_link >= filedata->file_header.e_shnum)
10661               break;
10662
10663             link_section = filedata->section_headers + section->sh_link;
10664             total = section->sh_size / sizeof (Elf_External_Versym);
10665
10666             if (link_section->sh_link >= filedata->file_header.e_shnum)
10667               break;
10668
10669             found = TRUE;
10670
10671             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10672             if (symbols == NULL)
10673               break;
10674
10675             string_sec = filedata->section_headers + link_section->sh_link;
10676
10677             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10678                                         string_sec->sh_size,
10679                                         _("version string table"));
10680             if (!strtab)
10681               {
10682                 free (symbols);
10683                 break;
10684               }
10685
10686             printf (ngettext ("\nVersion symbols section '%s' "
10687                               "contains %lu entry:\n",
10688                               "\nVersion symbols section '%s' "
10689                               "contains %lu entries:\n",
10690                               total),
10691                     printable_section_name (filedata, section), (unsigned long) total);
10692
10693             printf (_(" Addr: "));
10694             printf_vma (section->sh_addr);
10695             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10696                     (unsigned long) section->sh_offset, section->sh_link,
10697                     printable_section_name (filedata, link_section));
10698
10699             off = offset_from_vma (filedata,
10700                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10701                                    total * sizeof (short));
10702             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10703                                                 sizeof (short),
10704                                                 _("version symbol data"));
10705             if (!edata)
10706               {
10707                 free (strtab);
10708                 free (symbols);
10709                 break;
10710               }
10711
10712             data = (short unsigned int *) cmalloc (total, sizeof (short));
10713
10714             for (cnt = total; cnt --;)
10715               data[cnt] = byte_get (edata + cnt * sizeof (short),
10716                                     sizeof (short));
10717
10718             free (edata);
10719
10720             for (cnt = 0; cnt < total; cnt += 4)
10721               {
10722                 int j, nn;
10723                 char *name;
10724                 char *invalid = _("*invalid*");
10725
10726                 printf ("  %03x:", cnt);
10727
10728                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10729                   switch (data[cnt + j])
10730                     {
10731                     case 0:
10732                       fputs (_("   0 (*local*)    "), stdout);
10733                       break;
10734
10735                     case 1:
10736                       fputs (_("   1 (*global*)   "), stdout);
10737                       break;
10738
10739                     default:
10740                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10741                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10742
10743                       /* If this index value is greater than the size of the symbols
10744                          array, break to avoid an out-of-bounds read.  */
10745                       if ((unsigned long)(cnt + j) >= num_syms)
10746                         {
10747                           warn (_("invalid index into symbol array\n"));
10748                           break;
10749                         }
10750
10751                       name = NULL;
10752                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10753                         {
10754                           Elf_Internal_Verneed ivn;
10755                           unsigned long offset;
10756
10757                           offset = offset_from_vma
10758                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10759                              sizeof (Elf_External_Verneed));
10760
10761                           do
10762                             {
10763                               Elf_Internal_Vernaux ivna;
10764                               Elf_External_Verneed evn;
10765                               Elf_External_Vernaux evna;
10766                               unsigned long a_off;
10767
10768                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10769                                             _("version need")) == NULL)
10770                                 break;
10771
10772                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10773                               ivn.vn_next = BYTE_GET (evn.vn_next);
10774
10775                               a_off = offset + ivn.vn_aux;
10776
10777                               do
10778                                 {
10779                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10780                                                 1, _("version need aux (2)")) == NULL)
10781                                     {
10782                                       ivna.vna_next  = 0;
10783                                       ivna.vna_other = 0;
10784                                     }
10785                                   else
10786                                     {
10787                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10788                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10789                                     }
10790
10791                                   a_off += ivna.vna_next;
10792                                 }
10793                               while (ivna.vna_other != data[cnt + j]
10794                                      && ivna.vna_next != 0);
10795
10796                               if (ivna.vna_other == data[cnt + j])
10797                                 {
10798                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10799
10800                                   if (ivna.vna_name >= string_sec->sh_size)
10801                                     name = invalid;
10802                                   else
10803                                     name = strtab + ivna.vna_name;
10804                                   break;
10805                                 }
10806
10807                               offset += ivn.vn_next;
10808                             }
10809                           while (ivn.vn_next);
10810                         }
10811
10812                       if (data[cnt + j] != 0x8001
10813                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10814                         {
10815                           Elf_Internal_Verdef ivd;
10816                           Elf_External_Verdef evd;
10817                           unsigned long offset;
10818
10819                           offset = offset_from_vma
10820                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10821                              sizeof evd);
10822
10823                           do
10824                             {
10825                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10826                                             _("version def")) == NULL)
10827                                 {
10828                                   ivd.vd_next = 0;
10829                                   /* PR 17531: file: 046-1082287-0.004.  */
10830                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10831                                   break;
10832                                 }
10833                               else
10834                                 {
10835                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10836                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10837                                 }
10838
10839                               offset += ivd.vd_next;
10840                             }
10841                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10842                                  && ivd.vd_next != 0);
10843
10844                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10845                             {
10846                               Elf_External_Verdaux evda;
10847                               Elf_Internal_Verdaux ivda;
10848
10849                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10850
10851                               if (get_data (&evda, filedata,
10852                                             offset - ivd.vd_next + ivd.vd_aux,
10853                                             sizeof (evda), 1,
10854                                             _("version def aux")) == NULL)
10855                                 break;
10856
10857                               ivda.vda_name = BYTE_GET (evda.vda_name);
10858
10859                               if (ivda.vda_name >= string_sec->sh_size)
10860                                 name = invalid;
10861                               else if (name != NULL && name != invalid)
10862                                 name = _("*both*");
10863                               else
10864                                 name = strtab + ivda.vda_name;
10865                             }
10866                         }
10867                       if (name != NULL)
10868                         nn += printf ("(%s%-*s",
10869                                       name,
10870                                       12 - (int) strlen (name),
10871                                       ")");
10872
10873                       if (nn < 18)
10874                         printf ("%*c", 18 - nn, ' ');
10875                     }
10876
10877                 putchar ('\n');
10878               }
10879
10880             free (data);
10881             free (strtab);
10882             free (symbols);
10883           }
10884           break;
10885
10886         default:
10887           break;
10888         }
10889     }
10890
10891   if (! found)
10892     printf (_("\nNo version information found in this file.\n"));
10893
10894   return TRUE;
10895 }
10896
10897 static const char *
10898 get_symbol_binding (Filedata * filedata, unsigned int binding)
10899 {
10900   static char buff[32];
10901
10902   switch (binding)
10903     {
10904     case STB_LOCAL:     return "LOCAL";
10905     case STB_GLOBAL:    return "GLOBAL";
10906     case STB_WEAK:      return "WEAK";
10907     default:
10908       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10909         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10910                   binding);
10911       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10912         {
10913           if (binding == STB_GNU_UNIQUE
10914               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10915                   /* GNU is still using the default value 0.  */
10916                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10917             return "UNIQUE";
10918           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10919         }
10920       else
10921         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10922       return buff;
10923     }
10924 }
10925
10926 static const char *
10927 get_symbol_type (Filedata * filedata, unsigned int type)
10928 {
10929   static char buff[32];
10930
10931   switch (type)
10932     {
10933     case STT_NOTYPE:    return "NOTYPE";
10934     case STT_OBJECT:    return "OBJECT";
10935     case STT_FUNC:      return "FUNC";
10936     case STT_SECTION:   return "SECTION";
10937     case STT_FILE:      return "FILE";
10938     case STT_COMMON:    return "COMMON";
10939     case STT_TLS:       return "TLS";
10940     case STT_RELC:      return "RELC";
10941     case STT_SRELC:     return "SRELC";
10942     default:
10943       if (type >= STT_LOPROC && type <= STT_HIPROC)
10944         {
10945           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10946             return "THUMB_FUNC";
10947
10948           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10949             return "REGISTER";
10950
10951           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10952             return "PARISC_MILLI";
10953
10954           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10955         }
10956       else if (type >= STT_LOOS && type <= STT_HIOS)
10957         {
10958           if (filedata->file_header.e_machine == EM_PARISC)
10959             {
10960               if (type == STT_HP_OPAQUE)
10961                 return "HP_OPAQUE";
10962               if (type == STT_HP_STUB)
10963                 return "HP_STUB";
10964             }
10965
10966           if (type == STT_GNU_IFUNC
10967               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10968                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10969                   /* GNU is still using the default value 0.  */
10970                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10971             return "IFUNC";
10972
10973           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10974         }
10975       else
10976         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10977       return buff;
10978     }
10979 }
10980
10981 static const char *
10982 get_symbol_visibility (unsigned int visibility)
10983 {
10984   switch (visibility)
10985     {
10986     case STV_DEFAULT:   return "DEFAULT";
10987     case STV_INTERNAL:  return "INTERNAL";
10988     case STV_HIDDEN:    return "HIDDEN";
10989     case STV_PROTECTED: return "PROTECTED";
10990     default:
10991       error (_("Unrecognized visibility value: %u"), visibility);
10992       return _("<unknown>");
10993     }
10994 }
10995
10996 static const char *
10997 get_solaris_symbol_visibility (unsigned int visibility)
10998 {
10999   switch (visibility)
11000     {
11001     case 4: return "EXPORTED";
11002     case 5: return "SINGLETON";
11003     case 6: return "ELIMINATE";
11004     default: return get_symbol_visibility (visibility);
11005     }
11006 }
11007
11008 static const char *
11009 get_mips_symbol_other (unsigned int other)
11010 {
11011   switch (other)
11012     {
11013     case STO_OPTIONAL:      return "OPTIONAL";
11014     case STO_MIPS_PLT:      return "MIPS PLT";
11015     case STO_MIPS_PIC:      return "MIPS PIC";
11016     case STO_MICROMIPS:     return "MICROMIPS";
11017     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11018     case STO_MIPS16:        return "MIPS16";
11019     default:                return NULL;
11020     }
11021 }
11022
11023 static const char *
11024 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11025 {
11026   if (is_ia64_vms (filedata))
11027     {
11028       static char res[32];
11029
11030       res[0] = 0;
11031
11032       /* Function types is for images and .STB files only.  */
11033       switch (filedata->file_header.e_type)
11034         {
11035         case ET_DYN:
11036         case ET_EXEC:
11037           switch (VMS_ST_FUNC_TYPE (other))
11038             {
11039             case VMS_SFT_CODE_ADDR:
11040               strcat (res, " CA");
11041               break;
11042             case VMS_SFT_SYMV_IDX:
11043               strcat (res, " VEC");
11044               break;
11045             case VMS_SFT_FD:
11046               strcat (res, " FD");
11047               break;
11048             case VMS_SFT_RESERVE:
11049               strcat (res, " RSV");
11050               break;
11051             default:
11052               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11053                     VMS_ST_FUNC_TYPE (other));
11054               strcat (res, " <unknown>");
11055               break;
11056             }
11057           break;
11058         default:
11059           break;
11060         }
11061       switch (VMS_ST_LINKAGE (other))
11062         {
11063         case VMS_STL_IGNORE:
11064           strcat (res, " IGN");
11065           break;
11066         case VMS_STL_RESERVE:
11067           strcat (res, " RSV");
11068           break;
11069         case VMS_STL_STD:
11070           strcat (res, " STD");
11071           break;
11072         case VMS_STL_LNK:
11073           strcat (res, " LNK");
11074           break;
11075         default:
11076           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11077                 VMS_ST_LINKAGE (other));
11078           strcat (res, " <unknown>");
11079           break;
11080         }
11081
11082       if (res[0] != 0)
11083         return res + 1;
11084       else
11085         return res;
11086     }
11087   return NULL;
11088 }
11089
11090 static const char *
11091 get_ppc64_symbol_other (unsigned int other)
11092 {
11093   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11094     return NULL;
11095
11096   other >>= STO_PPC64_LOCAL_BIT;
11097   if (other <= 6)
11098     {
11099       static char buf[32];
11100       if (other >= 2)
11101         other = ppc64_decode_local_entry (other);
11102       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11103       return buf;
11104     }
11105   return NULL;
11106 }
11107
11108 static const char *
11109 get_symbol_other (Filedata * filedata, unsigned int other)
11110 {
11111   const char * result = NULL;
11112   static char buff [32];
11113
11114   if (other == 0)
11115     return "";
11116
11117   switch (filedata->file_header.e_machine)
11118     {
11119     case EM_MIPS:
11120       result = get_mips_symbol_other (other);
11121       break;
11122     case EM_IA_64:
11123       result = get_ia64_symbol_other (filedata, other);
11124       break;
11125     case EM_PPC64:
11126       result = get_ppc64_symbol_other (other);
11127       break;
11128     default:
11129       result = NULL;
11130       break;
11131     }
11132
11133   if (result)
11134     return result;
11135
11136   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11137   return buff;
11138 }
11139
11140 static const char *
11141 get_symbol_index_type (Filedata * filedata, unsigned int type)
11142 {
11143   static char buff[32];
11144
11145   switch (type)
11146     {
11147     case SHN_UNDEF:     return "UND";
11148     case SHN_ABS:       return "ABS";
11149     case SHN_COMMON:    return "COM";
11150     default:
11151       if (type == SHN_IA_64_ANSI_COMMON
11152           && filedata->file_header.e_machine == EM_IA_64
11153           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11154         return "ANSI_COM";
11155       else if ((filedata->file_header.e_machine == EM_X86_64
11156                 || filedata->file_header.e_machine == EM_L1OM
11157                 || filedata->file_header.e_machine == EM_K1OM)
11158                && type == SHN_X86_64_LCOMMON)
11159         return "LARGE_COM";
11160       else if ((type == SHN_MIPS_SCOMMON
11161                 && filedata->file_header.e_machine == EM_MIPS)
11162                || (type == SHN_TIC6X_SCOMMON
11163                    && filedata->file_header.e_machine == EM_TI_C6000))
11164         return "SCOM";
11165       else if (type == SHN_MIPS_SUNDEFINED
11166                && filedata->file_header.e_machine == EM_MIPS)
11167         return "SUND";
11168       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11169         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11170       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11171         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11172       else if (type >= SHN_LORESERVE)
11173         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11174       else if (type >= filedata->file_header.e_shnum)
11175         sprintf (buff, _("bad section index[%3d]"), type);
11176       else
11177         sprintf (buff, "%3d", type);
11178       break;
11179     }
11180
11181   return buff;
11182 }
11183
11184 static bfd_vma *
11185 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11186 {
11187   unsigned char * e_data;
11188   bfd_vma * i_data;
11189
11190   /* If the size_t type is smaller than the bfd_size_type, eg because
11191      you are building a 32-bit tool on a 64-bit host, then make sure
11192      that when (number) is cast to (size_t) no information is lost.  */
11193   if (sizeof (size_t) < sizeof (bfd_size_type)
11194       && (bfd_size_type) ((size_t) number) != number)
11195     {
11196       error (_("Size truncation prevents reading %s elements of size %u\n"),
11197              bfd_vmatoa ("u", number), ent_size);
11198       return NULL;
11199     }
11200
11201   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11202      attempting to allocate memory when the read is bound to fail.  */
11203   if (ent_size * number > filedata->file_size)
11204     {
11205       error (_("Invalid number of dynamic entries: %s\n"),
11206              bfd_vmatoa ("u", number));
11207       return NULL;
11208     }
11209
11210   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11211   if (e_data == NULL)
11212     {
11213       error (_("Out of memory reading %s dynamic entries\n"),
11214              bfd_vmatoa ("u", number));
11215       return NULL;
11216     }
11217
11218   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11219     {
11220       error (_("Unable to read in %s bytes of dynamic data\n"),
11221              bfd_vmatoa ("u", number * ent_size));
11222       free (e_data);
11223       return NULL;
11224     }
11225
11226   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11227   if (i_data == NULL)
11228     {
11229       error (_("Out of memory allocating space for %s dynamic entries\n"),
11230              bfd_vmatoa ("u", number));
11231       free (e_data);
11232       return NULL;
11233     }
11234
11235   while (number--)
11236     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11237
11238   free (e_data);
11239
11240   return i_data;
11241 }
11242
11243 static void
11244 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11245 {
11246   Elf_Internal_Sym * psym;
11247   int n;
11248
11249   n = print_vma (si, DEC_5);
11250   if (n < 5)
11251     fputs (&"     "[n], stdout);
11252   printf (" %3lu: ", hn);
11253
11254   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11255     {
11256       printf (_("<No info available for dynamic symbol number %lu>\n"),
11257               (unsigned long) si);
11258       return;
11259     }
11260
11261   psym = dynamic_symbols + si;
11262   print_vma (psym->st_value, LONG_HEX);
11263   putchar (' ');
11264   print_vma (psym->st_size, DEC_5);
11265
11266   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11267   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11268
11269   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11270     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11271   else
11272     {
11273       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11274
11275       printf (" %-7s",  get_symbol_visibility (vis));
11276       /* Check to see if any other bits in the st_other field are set.
11277          Note - displaying this information disrupts the layout of the
11278          table being generated, but for the moment this case is very
11279          rare.  */
11280       if (psym->st_other ^ vis)
11281         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11282     }
11283
11284   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11285   if (VALID_DYNAMIC_NAME (psym->st_name))
11286     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11287   else
11288     printf (_(" <corrupt: %14ld>"), psym->st_name);
11289   putchar ('\n');
11290 }
11291
11292 static const char *
11293 get_symbol_version_string (Filedata *                   filedata,
11294                            bfd_boolean                  is_dynsym,
11295                            const char *                 strtab,
11296                            unsigned long int            strtab_size,
11297                            unsigned int                 si,
11298                            Elf_Internal_Sym *           psym,
11299                            enum versioned_symbol_info * sym_info,
11300                            unsigned short *             vna_other)
11301 {
11302   unsigned char data[2];
11303   unsigned short vers_data;
11304   unsigned long offset;
11305   unsigned short max_vd_ndx;
11306
11307   if (!is_dynsym
11308       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11309     return NULL;
11310
11311   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11312                             sizeof data + si * sizeof (vers_data));
11313
11314   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11315                 sizeof (data), 1, _("version data")) == NULL)
11316     return NULL;
11317
11318   vers_data = byte_get (data, 2);
11319
11320   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11321     return NULL;
11322
11323   max_vd_ndx = 0;
11324
11325   /* Usually we'd only see verdef for defined symbols, and verneed for
11326      undefined symbols.  However, symbols defined by the linker in
11327      .dynbss for variables copied from a shared library in order to
11328      avoid text relocations are defined yet have verneed.  We could
11329      use a heuristic to detect the special case, for example, check
11330      for verneed first on symbols defined in SHT_NOBITS sections, but
11331      it is simpler and more reliable to just look for both verdef and
11332      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11333
11334   if (psym->st_shndx != SHN_UNDEF
11335       && vers_data != 0x8001
11336       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11337     {
11338       Elf_Internal_Verdef ivd;
11339       Elf_Internal_Verdaux ivda;
11340       Elf_External_Verdaux evda;
11341       unsigned long off;
11342
11343       off = offset_from_vma (filedata,
11344                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11345                              sizeof (Elf_External_Verdef));
11346
11347       do
11348         {
11349           Elf_External_Verdef evd;
11350
11351           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11352                         _("version def")) == NULL)
11353             {
11354               ivd.vd_ndx = 0;
11355               ivd.vd_aux = 0;
11356               ivd.vd_next = 0;
11357               ivd.vd_flags = 0;
11358             }
11359           else
11360             {
11361               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11362               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11363               ivd.vd_next = BYTE_GET (evd.vd_next);
11364               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11365             }
11366
11367           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11368             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11369
11370           off += ivd.vd_next;
11371         }
11372       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11373
11374       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11375         {
11376           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11377             return NULL;
11378
11379           off -= ivd.vd_next;
11380           off += ivd.vd_aux;
11381
11382           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11383                         _("version def aux")) != NULL)
11384             {
11385               ivda.vda_name = BYTE_GET (evda.vda_name);
11386
11387               if (psym->st_name != ivda.vda_name)
11388                 {
11389                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11390                                ? symbol_hidden : symbol_public);
11391                   return (ivda.vda_name < strtab_size
11392                           ? strtab + ivda.vda_name : _("<corrupt>"));
11393                 }
11394             }
11395         }
11396     }
11397
11398   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11399     {
11400       Elf_External_Verneed evn;
11401       Elf_Internal_Verneed ivn;
11402       Elf_Internal_Vernaux ivna;
11403
11404       offset = offset_from_vma (filedata,
11405                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11406                                 sizeof evn);
11407       do
11408         {
11409           unsigned long vna_off;
11410
11411           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11412                         _("version need")) == NULL)
11413             {
11414               ivna.vna_next = 0;
11415               ivna.vna_other = 0;
11416               ivna.vna_name = 0;
11417               break;
11418             }
11419
11420           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11421           ivn.vn_next = BYTE_GET (evn.vn_next);
11422
11423           vna_off = offset + ivn.vn_aux;
11424
11425           do
11426             {
11427               Elf_External_Vernaux evna;
11428
11429               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11430                             _("version need aux (3)")) == NULL)
11431                 {
11432                   ivna.vna_next = 0;
11433                   ivna.vna_other = 0;
11434                   ivna.vna_name = 0;
11435                 }
11436               else
11437                 {
11438                   ivna.vna_other = BYTE_GET (evna.vna_other);
11439                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11440                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11441                 }
11442
11443               vna_off += ivna.vna_next;
11444             }
11445           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11446
11447           if (ivna.vna_other == vers_data)
11448             break;
11449
11450           offset += ivn.vn_next;
11451         }
11452       while (ivn.vn_next != 0);
11453
11454       if (ivna.vna_other == vers_data)
11455         {
11456           *sym_info = symbol_undefined;
11457           *vna_other = ivna.vna_other;
11458           return (ivna.vna_name < strtab_size
11459                   ? strtab + ivna.vna_name : _("<corrupt>"));
11460         }
11461       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11462                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11463         return _("<corrupt>");
11464     }
11465   return NULL;
11466 }
11467
11468 /* Dump the symbol table.  */
11469 static bfd_boolean
11470 process_symbol_table (Filedata * filedata)
11471 {
11472   Elf_Internal_Shdr * section;
11473   bfd_size_type nbuckets = 0;
11474   bfd_size_type nchains = 0;
11475   bfd_vma * buckets = NULL;
11476   bfd_vma * chains = NULL;
11477   bfd_vma ngnubuckets = 0;
11478   bfd_vma * gnubuckets = NULL;
11479   bfd_vma * gnuchains = NULL;
11480   bfd_vma gnusymidx = 0;
11481   bfd_size_type ngnuchains = 0;
11482
11483   if (!do_syms && !do_dyn_syms && !do_histogram)
11484     return TRUE;
11485
11486   if (dynamic_info[DT_HASH]
11487       && (do_histogram
11488           || (do_using_dynamic
11489               && !do_dyn_syms
11490               && dynamic_strings != NULL)))
11491     {
11492       unsigned char nb[8];
11493       unsigned char nc[8];
11494       unsigned int hash_ent_size = 4;
11495
11496       if ((filedata->file_header.e_machine == EM_ALPHA
11497            || filedata->file_header.e_machine == EM_S390
11498            || filedata->file_header.e_machine == EM_S390_OLD)
11499           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11500         hash_ent_size = 8;
11501
11502       if (fseek (filedata->handle,
11503                  (archive_file_offset
11504                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11505                                      sizeof nb + sizeof nc)),
11506                  SEEK_SET))
11507         {
11508           error (_("Unable to seek to start of dynamic information\n"));
11509           goto no_hash;
11510         }
11511
11512       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11513         {
11514           error (_("Failed to read in number of buckets\n"));
11515           goto no_hash;
11516         }
11517
11518       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11519         {
11520           error (_("Failed to read in number of chains\n"));
11521           goto no_hash;
11522         }
11523
11524       nbuckets = byte_get (nb, hash_ent_size);
11525       nchains  = byte_get (nc, hash_ent_size);
11526
11527       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11528       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11529
11530     no_hash:
11531       if (buckets == NULL || chains == NULL)
11532         {
11533           if (do_using_dynamic)
11534             return FALSE;
11535           free (buckets);
11536           free (chains);
11537           buckets = NULL;
11538           chains = NULL;
11539           nbuckets = 0;
11540           nchains = 0;
11541         }
11542     }
11543
11544   if (dynamic_info_DT_GNU_HASH
11545       && (do_histogram
11546           || (do_using_dynamic
11547               && !do_dyn_syms
11548               && dynamic_strings != NULL)))
11549     {
11550       unsigned char nb[16];
11551       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11552       bfd_vma buckets_vma;
11553
11554       if (fseek (filedata->handle,
11555                  (archive_file_offset
11556                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11557                                      sizeof nb)),
11558                  SEEK_SET))
11559         {
11560           error (_("Unable to seek to start of dynamic information\n"));
11561           goto no_gnu_hash;
11562         }
11563
11564       if (fread (nb, 16, 1, filedata->handle) != 1)
11565         {
11566           error (_("Failed to read in number of buckets\n"));
11567           goto no_gnu_hash;
11568         }
11569
11570       ngnubuckets = byte_get (nb, 4);
11571       gnusymidx = byte_get (nb + 4, 4);
11572       bitmaskwords = byte_get (nb + 8, 4);
11573       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11574       if (is_32bit_elf)
11575         buckets_vma += bitmaskwords * 4;
11576       else
11577         buckets_vma += bitmaskwords * 8;
11578
11579       if (fseek (filedata->handle,
11580                  (archive_file_offset
11581                   + offset_from_vma (filedata, buckets_vma, 4)),
11582                  SEEK_SET))
11583         {
11584           error (_("Unable to seek to start of dynamic information\n"));
11585           goto no_gnu_hash;
11586         }
11587
11588       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11589
11590       if (gnubuckets == NULL)
11591         goto no_gnu_hash;
11592
11593       for (i = 0; i < ngnubuckets; i++)
11594         if (gnubuckets[i] != 0)
11595           {
11596             if (gnubuckets[i] < gnusymidx)
11597               return FALSE;
11598
11599             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11600               maxchain = gnubuckets[i];
11601           }
11602
11603       if (maxchain == 0xffffffff)
11604         goto no_gnu_hash;
11605
11606       maxchain -= gnusymidx;
11607
11608       if (fseek (filedata->handle,
11609                  (archive_file_offset
11610                   + offset_from_vma (filedata, buckets_vma
11611                                            + 4 * (ngnubuckets + maxchain), 4)),
11612                  SEEK_SET))
11613         {
11614           error (_("Unable to seek to start of dynamic information\n"));
11615           goto no_gnu_hash;
11616         }
11617
11618       do
11619         {
11620           if (fread (nb, 4, 1, filedata->handle) != 1)
11621             {
11622               error (_("Failed to determine last chain length\n"));
11623               goto no_gnu_hash;
11624             }
11625
11626           if (maxchain + 1 == 0)
11627             goto no_gnu_hash;
11628
11629           ++maxchain;
11630         }
11631       while ((byte_get (nb, 4) & 1) == 0);
11632
11633       if (fseek (filedata->handle,
11634                  (archive_file_offset
11635                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11636                  SEEK_SET))
11637         {
11638           error (_("Unable to seek to start of dynamic information\n"));
11639           goto no_gnu_hash;
11640         }
11641
11642       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11643       ngnuchains = maxchain;
11644
11645     no_gnu_hash:
11646       if (gnuchains == NULL)
11647         {
11648           free (gnubuckets);
11649           gnubuckets = NULL;
11650           ngnubuckets = 0;
11651           if (do_using_dynamic)
11652             return FALSE;
11653         }
11654     }
11655
11656   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11657       && do_syms
11658       && do_using_dynamic
11659       && dynamic_strings != NULL
11660       && dynamic_symbols != NULL)
11661     {
11662       unsigned long hn;
11663
11664       if (dynamic_info[DT_HASH])
11665         {
11666           bfd_vma si;
11667           char *visited;
11668
11669           printf (_("\nSymbol table for image:\n"));
11670           if (is_32bit_elf)
11671             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11672           else
11673             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11674
11675           visited = xcmalloc (nchains, 1);
11676           memset (visited, 0, nchains);
11677           for (hn = 0; hn < nbuckets; hn++)
11678             {
11679               for (si = buckets[hn]; si > 0; si = chains[si])
11680                 {
11681                   print_dynamic_symbol (filedata, si, hn);
11682                   if (si >= nchains || visited[si])
11683                     {
11684                       error (_("histogram chain is corrupt\n"));
11685                       break;
11686                     }
11687                   visited[si] = 1;
11688                 }
11689             }
11690           free (visited);
11691         }
11692
11693       if (dynamic_info_DT_GNU_HASH)
11694         {
11695           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11696           if (is_32bit_elf)
11697             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11698           else
11699             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11700
11701           for (hn = 0; hn < ngnubuckets; ++hn)
11702             if (gnubuckets[hn] != 0)
11703               {
11704                 bfd_vma si = gnubuckets[hn];
11705                 bfd_vma off = si - gnusymidx;
11706
11707                 do
11708                   {
11709                     print_dynamic_symbol (filedata, si, hn);
11710                     si++;
11711                   }
11712                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11713               }
11714         }
11715     }
11716   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11717            && filedata->section_headers != NULL)
11718     {
11719       unsigned int i;
11720
11721       for (i = 0, section = filedata->section_headers;
11722            i < filedata->file_header.e_shnum;
11723            i++, section++)
11724         {
11725           unsigned int si;
11726           char * strtab = NULL;
11727           unsigned long int strtab_size = 0;
11728           Elf_Internal_Sym * symtab;
11729           Elf_Internal_Sym * psym;
11730           unsigned long num_syms;
11731
11732           if ((section->sh_type != SHT_SYMTAB
11733                && section->sh_type != SHT_DYNSYM)
11734               || (!do_syms
11735                   && section->sh_type == SHT_SYMTAB))
11736             continue;
11737
11738           if (section->sh_entsize == 0)
11739             {
11740               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11741                       printable_section_name (filedata, section));
11742               continue;
11743             }
11744
11745           num_syms = section->sh_size / section->sh_entsize;
11746           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11747                             "\nSymbol table '%s' contains %lu entries:\n",
11748                             num_syms),
11749                   printable_section_name (filedata, section),
11750                   num_syms);
11751
11752           if (is_32bit_elf)
11753             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11754           else
11755             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11756
11757           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11758           if (symtab == NULL)
11759             continue;
11760
11761           if (section->sh_link == filedata->file_header.e_shstrndx)
11762             {
11763               strtab = filedata->string_table;
11764               strtab_size = filedata->string_table_length;
11765             }
11766           else if (section->sh_link < filedata->file_header.e_shnum)
11767             {
11768               Elf_Internal_Shdr * string_sec;
11769
11770               string_sec = filedata->section_headers + section->sh_link;
11771
11772               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11773                                           1, string_sec->sh_size,
11774                                           _("string table"));
11775               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11776             }
11777
11778           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11779             {
11780               const char *version_string;
11781               enum versioned_symbol_info sym_info;
11782               unsigned short vna_other;
11783
11784               printf ("%6d: ", si);
11785               print_vma (psym->st_value, LONG_HEX);
11786               putchar (' ');
11787               print_vma (psym->st_size, DEC_5);
11788               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11789               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11790               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11791                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11792               else
11793                 {
11794                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11795
11796                   printf (" %-7s", get_symbol_visibility (vis));
11797                   /* Check to see if any other bits in the st_other field are set.
11798                      Note - displaying this information disrupts the layout of the
11799                      table being generated, but for the moment this case is very rare.  */
11800                   if (psym->st_other ^ vis)
11801                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11802                 }
11803               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11804               print_symbol (25, psym->st_name < strtab_size
11805                             ? strtab + psym->st_name : _("<corrupt>"));
11806
11807               version_string
11808                 = get_symbol_version_string (filedata,
11809                                              section->sh_type == SHT_DYNSYM,
11810                                              strtab, strtab_size, si,
11811                                              psym, &sym_info, &vna_other);
11812               if (version_string)
11813                 {
11814                   if (sym_info == symbol_undefined)
11815                     printf ("@%s (%d)", version_string, vna_other);
11816                   else
11817                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11818                             version_string);
11819                 }
11820
11821               putchar ('\n');
11822
11823               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11824                   && si >= section->sh_info
11825                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11826                   && filedata->file_header.e_machine != EM_MIPS
11827                   /* Solaris binaries have been found to violate this requirement as
11828                      well.  Not sure if this is a bug or an ABI requirement.  */
11829                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11830                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11831                       si, printable_section_name (filedata, section), section->sh_info);
11832             }
11833
11834           free (symtab);
11835           if (strtab != filedata->string_table)
11836             free (strtab);
11837         }
11838     }
11839   else if (do_syms)
11840     printf
11841       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11842
11843   if (do_histogram && buckets != NULL)
11844     {
11845       unsigned long * lengths;
11846       unsigned long * counts;
11847       unsigned long hn;
11848       bfd_vma si;
11849       unsigned long maxlength = 0;
11850       unsigned long nzero_counts = 0;
11851       unsigned long nsyms = 0;
11852       char *visited;
11853
11854       printf (ngettext ("\nHistogram for bucket list length "
11855                         "(total of %lu bucket):\n",
11856                         "\nHistogram for bucket list length "
11857                         "(total of %lu buckets):\n",
11858                         (unsigned long) nbuckets),
11859               (unsigned long) nbuckets);
11860
11861       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11862       if (lengths == NULL)
11863         {
11864           error (_("Out of memory allocating space for histogram buckets\n"));
11865           return FALSE;
11866         }
11867       visited = xcmalloc (nchains, 1);
11868       memset (visited, 0, nchains);
11869
11870       printf (_(" Length  Number     %% of total  Coverage\n"));
11871       for (hn = 0; hn < nbuckets; ++hn)
11872         {
11873           for (si = buckets[hn]; si > 0; si = chains[si])
11874             {
11875               ++nsyms;
11876               if (maxlength < ++lengths[hn])
11877                 ++maxlength;
11878               if (si >= nchains || visited[si])
11879                 {
11880                   error (_("histogram chain is corrupt\n"));
11881                   break;
11882                 }
11883               visited[si] = 1;
11884             }
11885         }
11886       free (visited);
11887
11888       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11889       if (counts == NULL)
11890         {
11891           free (lengths);
11892           error (_("Out of memory allocating space for histogram counts\n"));
11893           return FALSE;
11894         }
11895
11896       for (hn = 0; hn < nbuckets; ++hn)
11897         ++counts[lengths[hn]];
11898
11899       if (nbuckets > 0)
11900         {
11901           unsigned long i;
11902           printf ("      0  %-10lu (%5.1f%%)\n",
11903                   counts[0], (counts[0] * 100.0) / nbuckets);
11904           for (i = 1; i <= maxlength; ++i)
11905             {
11906               nzero_counts += counts[i] * i;
11907               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11908                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11909                       (nzero_counts * 100.0) / nsyms);
11910             }
11911         }
11912
11913       free (counts);
11914       free (lengths);
11915     }
11916
11917   if (buckets != NULL)
11918     {
11919       free (buckets);
11920       free (chains);
11921     }
11922
11923   if (do_histogram && gnubuckets != NULL)
11924     {
11925       unsigned long * lengths;
11926       unsigned long * counts;
11927       unsigned long hn;
11928       unsigned long maxlength = 0;
11929       unsigned long nzero_counts = 0;
11930       unsigned long nsyms = 0;
11931
11932       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11933                         "(total of %lu bucket):\n",
11934                         "\nHistogram for `.gnu.hash' bucket list length "
11935                         "(total of %lu buckets):\n",
11936                         (unsigned long) ngnubuckets),
11937               (unsigned long) ngnubuckets);
11938
11939       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11940       if (lengths == NULL)
11941         {
11942           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11943           return FALSE;
11944         }
11945
11946       printf (_(" Length  Number     %% of total  Coverage\n"));
11947
11948       for (hn = 0; hn < ngnubuckets; ++hn)
11949         if (gnubuckets[hn] != 0)
11950           {
11951             bfd_vma off, length = 1;
11952
11953             for (off = gnubuckets[hn] - gnusymidx;
11954                  /* PR 17531 file: 010-77222-0.004.  */
11955                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11956                  ++off)
11957               ++length;
11958             lengths[hn] = length;
11959             if (length > maxlength)
11960               maxlength = length;
11961             nsyms += length;
11962           }
11963
11964       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11965       if (counts == NULL)
11966         {
11967           free (lengths);
11968           error (_("Out of memory allocating space for gnu histogram counts\n"));
11969           return FALSE;
11970         }
11971
11972       for (hn = 0; hn < ngnubuckets; ++hn)
11973         ++counts[lengths[hn]];
11974
11975       if (ngnubuckets > 0)
11976         {
11977           unsigned long j;
11978           printf ("      0  %-10lu (%5.1f%%)\n",
11979                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11980           for (j = 1; j <= maxlength; ++j)
11981             {
11982               nzero_counts += counts[j] * j;
11983               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11984                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11985                       (nzero_counts * 100.0) / nsyms);
11986             }
11987         }
11988
11989       free (counts);
11990       free (lengths);
11991       free (gnubuckets);
11992       free (gnuchains);
11993     }
11994
11995   return TRUE;
11996 }
11997
11998 static bfd_boolean
11999 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12000 {
12001   unsigned int i;
12002
12003   if (dynamic_syminfo == NULL
12004       || !do_dynamic)
12005     /* No syminfo, this is ok.  */
12006     return TRUE;
12007
12008   /* There better should be a dynamic symbol section.  */
12009   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12010     return FALSE;
12011
12012   if (dynamic_addr)
12013     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12014                       "contains %d entry:\n",
12015                       "\nDynamic info segment at offset 0x%lx "
12016                       "contains %d entries:\n",
12017                       dynamic_syminfo_nent),
12018             dynamic_syminfo_offset, dynamic_syminfo_nent);
12019
12020   printf (_(" Num: Name                           BoundTo     Flags\n"));
12021   for (i = 0; i < dynamic_syminfo_nent; ++i)
12022     {
12023       unsigned short int flags = dynamic_syminfo[i].si_flags;
12024
12025       printf ("%4d: ", i);
12026       if (i >= num_dynamic_syms)
12027         printf (_("<corrupt index>"));
12028       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12029         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12030       else
12031         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12032       putchar (' ');
12033
12034       switch (dynamic_syminfo[i].si_boundto)
12035         {
12036         case SYMINFO_BT_SELF:
12037           fputs ("SELF       ", stdout);
12038           break;
12039         case SYMINFO_BT_PARENT:
12040           fputs ("PARENT     ", stdout);
12041           break;
12042         default:
12043           if (dynamic_syminfo[i].si_boundto > 0
12044               && dynamic_syminfo[i].si_boundto < dynamic_nent
12045               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12046             {
12047               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12048               putchar (' ' );
12049             }
12050           else
12051             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12052           break;
12053         }
12054
12055       if (flags & SYMINFO_FLG_DIRECT)
12056         printf (" DIRECT");
12057       if (flags & SYMINFO_FLG_PASSTHRU)
12058         printf (" PASSTHRU");
12059       if (flags & SYMINFO_FLG_COPY)
12060         printf (" COPY");
12061       if (flags & SYMINFO_FLG_LAZYLOAD)
12062         printf (" LAZYLOAD");
12063
12064       puts ("");
12065     }
12066
12067   return TRUE;
12068 }
12069
12070 #define IN_RANGE(START,END,ADDR,OFF)            \
12071   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12072
12073 /* Check to see if the given reloc needs to be handled in a target specific
12074    manner.  If so then process the reloc and return TRUE otherwise return
12075    FALSE.
12076
12077    If called with reloc == NULL, then this is a signal that reloc processing
12078    for the current section has finished, and any saved state should be
12079    discarded.  */
12080
12081 static bfd_boolean
12082 target_specific_reloc_handling (Filedata *           filedata,
12083                                 Elf_Internal_Rela *  reloc,
12084                                 unsigned char *      start,
12085                                 unsigned char *      end,
12086                                 Elf_Internal_Sym *   symtab,
12087                                 unsigned long        num_syms)
12088 {
12089   unsigned int reloc_type = 0;
12090   unsigned long sym_index = 0;
12091
12092   if (reloc)
12093     {
12094       reloc_type = get_reloc_type (filedata, reloc->r_info);
12095       sym_index = get_reloc_symindex (reloc->r_info);
12096     }
12097
12098   switch (filedata->file_header.e_machine)
12099     {
12100     case EM_MSP430:
12101     case EM_MSP430_OLD:
12102       {
12103         static Elf_Internal_Sym * saved_sym = NULL;
12104
12105         if (reloc == NULL)
12106           {
12107             saved_sym = NULL;
12108             return TRUE;
12109           }
12110
12111         switch (reloc_type)
12112           {
12113           case 10: /* R_MSP430_SYM_DIFF */
12114             if (uses_msp430x_relocs (filedata))
12115               break;
12116             /* Fall through.  */
12117           case 21: /* R_MSP430X_SYM_DIFF */
12118             /* PR 21139.  */
12119             if (sym_index >= num_syms)
12120               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12121                      sym_index);
12122             else
12123               saved_sym = symtab + sym_index;
12124             return TRUE;
12125
12126           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12127           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12128             goto handle_sym_diff;
12129
12130           case 5: /* R_MSP430_16_BYTE */
12131           case 9: /* R_MSP430_8 */
12132             if (uses_msp430x_relocs (filedata))
12133               break;
12134             goto handle_sym_diff;
12135
12136           case 2: /* R_MSP430_ABS16 */
12137           case 15: /* R_MSP430X_ABS16 */
12138             if (! uses_msp430x_relocs (filedata))
12139               break;
12140             goto handle_sym_diff;
12141
12142           handle_sym_diff:
12143             if (saved_sym != NULL)
12144               {
12145                 int reloc_size = reloc_type == 1 ? 4 : 2;
12146                 bfd_vma value;
12147
12148                 if (sym_index >= num_syms)
12149                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12150                          sym_index);
12151                 else
12152                   {
12153                     value = reloc->r_addend + (symtab[sym_index].st_value
12154                                                - saved_sym->st_value);
12155
12156                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12157                       byte_put (start + reloc->r_offset, value, reloc_size);
12158                     else
12159                       /* PR 21137 */
12160                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12161                              (long) reloc->r_offset);
12162                   }
12163
12164                 saved_sym = NULL;
12165                 return TRUE;
12166               }
12167             break;
12168
12169           default:
12170             if (saved_sym != NULL)
12171               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12172             break;
12173           }
12174         break;
12175       }
12176
12177     case EM_MN10300:
12178     case EM_CYGNUS_MN10300:
12179       {
12180         static Elf_Internal_Sym * saved_sym = NULL;
12181
12182         if (reloc == NULL)
12183           {
12184             saved_sym = NULL;
12185             return TRUE;
12186           }
12187
12188         switch (reloc_type)
12189           {
12190           case 34: /* R_MN10300_ALIGN */
12191             return TRUE;
12192           case 33: /* R_MN10300_SYM_DIFF */
12193             if (sym_index >= num_syms)
12194               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12195                      sym_index);
12196             else
12197               saved_sym = symtab + sym_index;
12198             return TRUE;
12199
12200           case 1: /* R_MN10300_32 */
12201           case 2: /* R_MN10300_16 */
12202             if (saved_sym != NULL)
12203               {
12204                 int reloc_size = reloc_type == 1 ? 4 : 2;
12205                 bfd_vma value;
12206
12207                 if (sym_index >= num_syms)
12208                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12209                          sym_index);
12210                 else
12211                   {
12212                     value = reloc->r_addend + (symtab[sym_index].st_value
12213                                                - saved_sym->st_value);
12214
12215                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12216                       byte_put (start + reloc->r_offset, value, reloc_size);
12217                     else
12218                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12219                              (long) reloc->r_offset);
12220                   }
12221
12222                 saved_sym = NULL;
12223                 return TRUE;
12224               }
12225             break;
12226           default:
12227             if (saved_sym != NULL)
12228               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12229             break;
12230           }
12231         break;
12232       }
12233
12234     case EM_RL78:
12235       {
12236         static bfd_vma saved_sym1 = 0;
12237         static bfd_vma saved_sym2 = 0;
12238         static bfd_vma value;
12239
12240         if (reloc == NULL)
12241           {
12242             saved_sym1 = saved_sym2 = 0;
12243             return TRUE;
12244           }
12245
12246         switch (reloc_type)
12247           {
12248           case 0x80: /* R_RL78_SYM.  */
12249             saved_sym1 = saved_sym2;
12250             if (sym_index >= num_syms)
12251               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12252                      sym_index);
12253             else
12254               {
12255                 saved_sym2 = symtab[sym_index].st_value;
12256                 saved_sym2 += reloc->r_addend;
12257               }
12258             return TRUE;
12259
12260           case 0x83: /* R_RL78_OPsub.  */
12261             value = saved_sym1 - saved_sym2;
12262             saved_sym2 = saved_sym1 = 0;
12263             return TRUE;
12264             break;
12265
12266           case 0x41: /* R_RL78_ABS32.  */
12267             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12268               byte_put (start + reloc->r_offset, value, 4);
12269             else
12270               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12271                      (long) reloc->r_offset);
12272             value = 0;
12273             return TRUE;
12274
12275           case 0x43: /* R_RL78_ABS16.  */
12276             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12277               byte_put (start + reloc->r_offset, value, 2);
12278             else
12279               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12280                      (long) reloc->r_offset);
12281             value = 0;
12282             return TRUE;
12283
12284           default:
12285             break;
12286           }
12287         break;
12288       }
12289     }
12290
12291   return FALSE;
12292 }
12293
12294 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12295    DWARF debug sections.  This is a target specific test.  Note - we do not
12296    go through the whole including-target-headers-multiple-times route, (as
12297    we have already done with <elf/h8.h>) because this would become very
12298    messy and even then this function would have to contain target specific
12299    information (the names of the relocs instead of their numeric values).
12300    FIXME: This is not the correct way to solve this problem.  The proper way
12301    is to have target specific reloc sizing and typing functions created by
12302    the reloc-macros.h header, in the same way that it already creates the
12303    reloc naming functions.  */
12304
12305 static bfd_boolean
12306 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12307 {
12308   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12309   switch (filedata->file_header.e_machine)
12310     {
12311     case EM_386:
12312     case EM_IAMCU:
12313       return reloc_type == 1; /* R_386_32.  */
12314     case EM_68K:
12315       return reloc_type == 1; /* R_68K_32.  */
12316     case EM_860:
12317       return reloc_type == 1; /* R_860_32.  */
12318     case EM_960:
12319       return reloc_type == 2; /* R_960_32.  */
12320     case EM_AARCH64:
12321       return (reloc_type == 258
12322               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12323     case EM_ADAPTEVA_EPIPHANY:
12324       return reloc_type == 3;
12325     case EM_ALPHA:
12326       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12327     case EM_ARC:
12328       return reloc_type == 1; /* R_ARC_32.  */
12329     case EM_ARC_COMPACT:
12330     case EM_ARC_COMPACT2:
12331       return reloc_type == 4; /* R_ARC_32.  */
12332     case EM_ARM:
12333       return reloc_type == 2; /* R_ARM_ABS32 */
12334     case EM_AVR_OLD:
12335     case EM_AVR:
12336       return reloc_type == 1;
12337     case EM_BLACKFIN:
12338       return reloc_type == 0x12; /* R_byte4_data.  */
12339     case EM_CRIS:
12340       return reloc_type == 3; /* R_CRIS_32.  */
12341     case EM_CR16:
12342       return reloc_type == 3; /* R_CR16_NUM32.  */
12343     case EM_CRX:
12344       return reloc_type == 15; /* R_CRX_NUM32.  */
12345     case EM_CSKY:
12346       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12347     case EM_CYGNUS_FRV:
12348       return reloc_type == 1;
12349     case EM_CYGNUS_D10V:
12350     case EM_D10V:
12351       return reloc_type == 6; /* R_D10V_32.  */
12352     case EM_CYGNUS_D30V:
12353     case EM_D30V:
12354       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12355     case EM_DLX:
12356       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12357     case EM_CYGNUS_FR30:
12358     case EM_FR30:
12359       return reloc_type == 3; /* R_FR30_32.  */
12360     case EM_FT32:
12361       return reloc_type == 1; /* R_FT32_32.  */
12362     case EM_H8S:
12363     case EM_H8_300:
12364     case EM_H8_300H:
12365       return reloc_type == 1; /* R_H8_DIR32.  */
12366     case EM_IA_64:
12367       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12368               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12369               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12370               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12371     case EM_IP2K_OLD:
12372     case EM_IP2K:
12373       return reloc_type == 2; /* R_IP2K_32.  */
12374     case EM_IQ2000:
12375       return reloc_type == 2; /* R_IQ2000_32.  */
12376     case EM_LATTICEMICO32:
12377       return reloc_type == 3; /* R_LM32_32.  */
12378     case EM_M32C_OLD:
12379     case EM_M32C:
12380       return reloc_type == 3; /* R_M32C_32.  */
12381     case EM_M32R:
12382       return reloc_type == 34; /* R_M32R_32_RELA.  */
12383     case EM_68HC11:
12384     case EM_68HC12:
12385       return reloc_type == 6; /* R_M68HC11_32.  */
12386     case EM_S12Z:
12387       return reloc_type == 6; /* R_S12Z_EXT32.  */
12388     case EM_MCORE:
12389       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12390     case EM_CYGNUS_MEP:
12391       return reloc_type == 4; /* R_MEP_32.  */
12392     case EM_METAG:
12393       return reloc_type == 2; /* R_METAG_ADDR32.  */
12394     case EM_MICROBLAZE:
12395       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12396     case EM_MIPS:
12397       return reloc_type == 2; /* R_MIPS_32.  */
12398     case EM_MMIX:
12399       return reloc_type == 4; /* R_MMIX_32.  */
12400     case EM_CYGNUS_MN10200:
12401     case EM_MN10200:
12402       return reloc_type == 1; /* R_MN10200_32.  */
12403     case EM_CYGNUS_MN10300:
12404     case EM_MN10300:
12405       return reloc_type == 1; /* R_MN10300_32.  */
12406     case EM_MOXIE:
12407       return reloc_type == 1; /* R_MOXIE_32.  */
12408     case EM_MSP430_OLD:
12409     case EM_MSP430:
12410       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12411     case EM_MT:
12412       return reloc_type == 2; /* R_MT_32.  */
12413     case EM_NDS32:
12414       return reloc_type == 20; /* R_NDS32_RELA.  */
12415     case EM_ALTERA_NIOS2:
12416       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12417     case EM_NIOS32:
12418       return reloc_type == 1; /* R_NIOS_32.  */
12419     case EM_OR1K:
12420       return reloc_type == 1; /* R_OR1K_32.  */
12421     case EM_PARISC:
12422       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12423               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12424               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12425     case EM_PJ:
12426     case EM_PJ_OLD:
12427       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12428     case EM_PPC64:
12429       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12430     case EM_PPC:
12431       return reloc_type == 1; /* R_PPC_ADDR32.  */
12432     case EM_TI_PRU:
12433       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12434     case EM_RISCV:
12435       return reloc_type == 1; /* R_RISCV_32.  */
12436     case EM_RL78:
12437       return reloc_type == 1; /* R_RL78_DIR32.  */
12438     case EM_RX:
12439       return reloc_type == 1; /* R_RX_DIR32.  */
12440     case EM_S370:
12441       return reloc_type == 1; /* R_I370_ADDR31.  */
12442     case EM_S390_OLD:
12443     case EM_S390:
12444       return reloc_type == 4; /* R_S390_32.  */
12445     case EM_SCORE:
12446       return reloc_type == 8; /* R_SCORE_ABS32.  */
12447     case EM_SH:
12448       return reloc_type == 1; /* R_SH_DIR32.  */
12449     case EM_SPARC32PLUS:
12450     case EM_SPARCV9:
12451     case EM_SPARC:
12452       return reloc_type == 3 /* R_SPARC_32.  */
12453         || reloc_type == 23; /* R_SPARC_UA32.  */
12454     case EM_SPU:
12455       return reloc_type == 6; /* R_SPU_ADDR32 */
12456     case EM_TI_C6000:
12457       return reloc_type == 1; /* R_C6000_ABS32.  */
12458     case EM_TILEGX:
12459       return reloc_type == 2; /* R_TILEGX_32.  */
12460     case EM_TILEPRO:
12461       return reloc_type == 1; /* R_TILEPRO_32.  */
12462     case EM_CYGNUS_V850:
12463     case EM_V850:
12464       return reloc_type == 6; /* R_V850_ABS32.  */
12465     case EM_V800:
12466       return reloc_type == 0x33; /* R_V810_WORD.  */
12467     case EM_VAX:
12468       return reloc_type == 1; /* R_VAX_32.  */
12469     case EM_VISIUM:
12470       return reloc_type == 3;  /* R_VISIUM_32. */
12471     case EM_WEBASSEMBLY:
12472       return reloc_type == 1;  /* R_WASM32_32.  */
12473     case EM_X86_64:
12474     case EM_L1OM:
12475     case EM_K1OM:
12476       return reloc_type == 10; /* R_X86_64_32.  */
12477     case EM_XC16X:
12478     case EM_C166:
12479       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12480     case EM_XGATE:
12481       return reloc_type == 4; /* R_XGATE_32.  */
12482     case EM_XSTORMY16:
12483       return reloc_type == 1; /* R_XSTROMY16_32.  */
12484     case EM_XTENSA_OLD:
12485     case EM_XTENSA:
12486       return reloc_type == 1; /* R_XTENSA_32.  */
12487     default:
12488       {
12489         static unsigned int prev_warn = 0;
12490
12491         /* Avoid repeating the same warning multiple times.  */
12492         if (prev_warn != filedata->file_header.e_machine)
12493           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12494                  filedata->file_header.e_machine);
12495         prev_warn = filedata->file_header.e_machine;
12496         return FALSE;
12497       }
12498     }
12499 }
12500
12501 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12502    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12503
12504 static bfd_boolean
12505 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12506 {
12507   switch (filedata->file_header.e_machine)
12508   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12509     {
12510     case EM_386:
12511     case EM_IAMCU:
12512       return reloc_type == 2;  /* R_386_PC32.  */
12513     case EM_68K:
12514       return reloc_type == 4;  /* R_68K_PC32.  */
12515     case EM_AARCH64:
12516       return reloc_type == 261; /* R_AARCH64_PREL32 */
12517     case EM_ADAPTEVA_EPIPHANY:
12518       return reloc_type == 6;
12519     case EM_ALPHA:
12520       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12521     case EM_ARC_COMPACT:
12522     case EM_ARC_COMPACT2:
12523       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12524     case EM_ARM:
12525       return reloc_type == 3;  /* R_ARM_REL32 */
12526     case EM_AVR_OLD:
12527     case EM_AVR:
12528       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12529     case EM_MICROBLAZE:
12530       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12531     case EM_OR1K:
12532       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12533     case EM_PARISC:
12534       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12535     case EM_PPC:
12536       return reloc_type == 26; /* R_PPC_REL32.  */
12537     case EM_PPC64:
12538       return reloc_type == 26; /* R_PPC64_REL32.  */
12539     case EM_S390_OLD:
12540     case EM_S390:
12541       return reloc_type == 5;  /* R_390_PC32.  */
12542     case EM_SH:
12543       return reloc_type == 2;  /* R_SH_REL32.  */
12544     case EM_SPARC32PLUS:
12545     case EM_SPARCV9:
12546     case EM_SPARC:
12547       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12548     case EM_SPU:
12549       return reloc_type == 13; /* R_SPU_REL32.  */
12550     case EM_TILEGX:
12551       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12552     case EM_TILEPRO:
12553       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12554     case EM_VISIUM:
12555       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12556     case EM_X86_64:
12557     case EM_L1OM:
12558     case EM_K1OM:
12559       return reloc_type == 2;  /* R_X86_64_PC32.  */
12560     case EM_XTENSA_OLD:
12561     case EM_XTENSA:
12562       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12563     default:
12564       /* Do not abort or issue an error message here.  Not all targets use
12565          pc-relative 32-bit relocs in their DWARF debug information and we
12566          have already tested for target coverage in is_32bit_abs_reloc.  A
12567          more helpful warning message will be generated by apply_relocations
12568          anyway, so just return.  */
12569       return FALSE;
12570     }
12571 }
12572
12573 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12574    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12575
12576 static bfd_boolean
12577 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12578 {
12579   switch (filedata->file_header.e_machine)
12580     {
12581     case EM_AARCH64:
12582       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12583     case EM_ALPHA:
12584       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12585     case EM_IA_64:
12586       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12587               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12588     case EM_PARISC:
12589       return reloc_type == 80; /* R_PARISC_DIR64.  */
12590     case EM_PPC64:
12591       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12592     case EM_RISCV:
12593       return reloc_type == 2; /* R_RISCV_64.  */
12594     case EM_SPARC32PLUS:
12595     case EM_SPARCV9:
12596     case EM_SPARC:
12597       return reloc_type == 32 /* R_SPARC_64.  */
12598         || reloc_type == 54; /* R_SPARC_UA64.  */
12599     case EM_X86_64:
12600     case EM_L1OM:
12601     case EM_K1OM:
12602       return reloc_type == 1; /* R_X86_64_64.  */
12603     case EM_S390_OLD:
12604     case EM_S390:
12605       return reloc_type == 22;  /* R_S390_64.  */
12606     case EM_TILEGX:
12607       return reloc_type == 1; /* R_TILEGX_64.  */
12608     case EM_MIPS:
12609       return reloc_type == 18;  /* R_MIPS_64.  */
12610     default:
12611       return FALSE;
12612     }
12613 }
12614
12615 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12616    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12617
12618 static bfd_boolean
12619 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12620 {
12621   switch (filedata->file_header.e_machine)
12622     {
12623     case EM_AARCH64:
12624       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12625     case EM_ALPHA:
12626       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12627     case EM_IA_64:
12628       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12629               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12630     case EM_PARISC:
12631       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12632     case EM_PPC64:
12633       return reloc_type == 44; /* R_PPC64_REL64.  */
12634     case EM_SPARC32PLUS:
12635     case EM_SPARCV9:
12636     case EM_SPARC:
12637       return reloc_type == 46; /* R_SPARC_DISP64.  */
12638     case EM_X86_64:
12639     case EM_L1OM:
12640     case EM_K1OM:
12641       return reloc_type == 24; /* R_X86_64_PC64.  */
12642     case EM_S390_OLD:
12643     case EM_S390:
12644       return reloc_type == 23;  /* R_S390_PC64.  */
12645     case EM_TILEGX:
12646       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12647     default:
12648       return FALSE;
12649     }
12650 }
12651
12652 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12653    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12654
12655 static bfd_boolean
12656 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12657 {
12658   switch (filedata->file_header.e_machine)
12659     {
12660     case EM_CYGNUS_MN10200:
12661     case EM_MN10200:
12662       return reloc_type == 4; /* R_MN10200_24.  */
12663     case EM_FT32:
12664       return reloc_type == 5; /* R_FT32_20.  */
12665     default:
12666       return FALSE;
12667     }
12668 }
12669
12670 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12671    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12672
12673 static bfd_boolean
12674 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12675 {
12676   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12677   switch (filedata->file_header.e_machine)
12678     {
12679     case EM_ARC:
12680     case EM_ARC_COMPACT:
12681     case EM_ARC_COMPACT2:
12682       return reloc_type == 2; /* R_ARC_16.  */
12683     case EM_ADAPTEVA_EPIPHANY:
12684       return reloc_type == 5;
12685     case EM_AVR_OLD:
12686     case EM_AVR:
12687       return reloc_type == 4; /* R_AVR_16.  */
12688     case EM_CYGNUS_D10V:
12689     case EM_D10V:
12690       return reloc_type == 3; /* R_D10V_16.  */
12691     case EM_FT32:
12692       return reloc_type == 2; /* R_FT32_16.  */
12693     case EM_H8S:
12694     case EM_H8_300:
12695     case EM_H8_300H:
12696       return reloc_type == R_H8_DIR16;
12697     case EM_IP2K_OLD:
12698     case EM_IP2K:
12699       return reloc_type == 1; /* R_IP2K_16.  */
12700     case EM_M32C_OLD:
12701     case EM_M32C:
12702       return reloc_type == 1; /* R_M32C_16 */
12703     case EM_CYGNUS_MN10200:
12704     case EM_MN10200:
12705       return reloc_type == 2; /* R_MN10200_16.  */
12706     case EM_CYGNUS_MN10300:
12707     case EM_MN10300:
12708       return reloc_type == 2; /* R_MN10300_16.  */
12709     case EM_MSP430:
12710       if (uses_msp430x_relocs (filedata))
12711         return reloc_type == 2; /* R_MSP430_ABS16.  */
12712       /* Fall through.  */
12713     case EM_MSP430_OLD:
12714       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12715     case EM_NDS32:
12716       return reloc_type == 19; /* R_NDS32_RELA.  */
12717     case EM_ALTERA_NIOS2:
12718       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12719     case EM_NIOS32:
12720       return reloc_type == 9; /* R_NIOS_16.  */
12721     case EM_OR1K:
12722       return reloc_type == 2; /* R_OR1K_16.  */
12723     case EM_RISCV:
12724       return reloc_type == 55; /* R_RISCV_SET16.  */
12725     case EM_TI_PRU:
12726       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12727     case EM_TI_C6000:
12728       return reloc_type == 2; /* R_C6000_ABS16.  */
12729     case EM_VISIUM:
12730       return reloc_type == 2; /* R_VISIUM_16. */
12731     case EM_XC16X:
12732     case EM_C166:
12733       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12734     case EM_XGATE:
12735       return reloc_type == 3; /* R_XGATE_16.  */
12736     default:
12737       return FALSE;
12738     }
12739 }
12740
12741 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12742    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12743
12744 static bfd_boolean
12745 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12746 {
12747   switch (filedata->file_header.e_machine)
12748     {
12749     case EM_RISCV:
12750       return reloc_type == 54; /* R_RISCV_SET8.  */
12751     default:
12752       return FALSE;
12753     }
12754 }
12755
12756 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12757    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12758
12759 static bfd_boolean
12760 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12761 {
12762   switch (filedata->file_header.e_machine)
12763     {
12764     case EM_RISCV:
12765       return reloc_type == 53; /* R_RISCV_SET6.  */
12766     default:
12767       return FALSE;
12768     }
12769 }
12770
12771 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12772    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12773
12774 static bfd_boolean
12775 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12776 {
12777   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12778   switch (filedata->file_header.e_machine)
12779     {
12780     case EM_RISCV:
12781       return reloc_type == 35; /* R_RISCV_ADD32.  */
12782     default:
12783       return FALSE;
12784     }
12785 }
12786
12787 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12788    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12789
12790 static bfd_boolean
12791 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12792 {
12793   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12794   switch (filedata->file_header.e_machine)
12795     {
12796     case EM_RISCV:
12797       return reloc_type == 39; /* R_RISCV_SUB32.  */
12798     default:
12799       return FALSE;
12800     }
12801 }
12802
12803 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12804    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12805
12806 static bfd_boolean
12807 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12808 {
12809   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12810   switch (filedata->file_header.e_machine)
12811     {
12812     case EM_RISCV:
12813       return reloc_type == 36; /* R_RISCV_ADD64.  */
12814     default:
12815       return FALSE;
12816     }
12817 }
12818
12819 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12820    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12821
12822 static bfd_boolean
12823 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12824 {
12825   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12826   switch (filedata->file_header.e_machine)
12827     {
12828     case EM_RISCV:
12829       return reloc_type == 40; /* R_RISCV_SUB64.  */
12830     default:
12831       return FALSE;
12832     }
12833 }
12834
12835 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12836    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12837
12838 static bfd_boolean
12839 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12840 {
12841   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12842   switch (filedata->file_header.e_machine)
12843     {
12844     case EM_RISCV:
12845       return reloc_type == 34; /* R_RISCV_ADD16.  */
12846     default:
12847       return FALSE;
12848     }
12849 }
12850
12851 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12852    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12853
12854 static bfd_boolean
12855 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12856 {
12857   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12858   switch (filedata->file_header.e_machine)
12859     {
12860     case EM_RISCV:
12861       return reloc_type == 38; /* R_RISCV_SUB16.  */
12862     default:
12863       return FALSE;
12864     }
12865 }
12866
12867 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12868    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12869
12870 static bfd_boolean
12871 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12872 {
12873   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12874   switch (filedata->file_header.e_machine)
12875     {
12876     case EM_RISCV:
12877       return reloc_type == 33; /* R_RISCV_ADD8.  */
12878     default:
12879       return FALSE;
12880     }
12881 }
12882
12883 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12884    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12885
12886 static bfd_boolean
12887 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12888 {
12889   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12890   switch (filedata->file_header.e_machine)
12891     {
12892     case EM_RISCV:
12893       return reloc_type == 37; /* R_RISCV_SUB8.  */
12894     default:
12895       return FALSE;
12896     }
12897 }
12898
12899 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12900    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12901
12902 static bfd_boolean
12903 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12904 {
12905   switch (filedata->file_header.e_machine)
12906     {
12907     case EM_RISCV:
12908       return reloc_type == 52; /* R_RISCV_SUB6.  */
12909     default:
12910       return FALSE;
12911     }
12912 }
12913
12914 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12915    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12916
12917 static bfd_boolean
12918 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12919 {
12920   switch (filedata->file_header.e_machine)
12921     {
12922     case EM_386:     /* R_386_NONE.  */
12923     case EM_68K:     /* R_68K_NONE.  */
12924     case EM_ADAPTEVA_EPIPHANY:
12925     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12926     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12927     case EM_ARC:     /* R_ARC_NONE.  */
12928     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12929     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12930     case EM_ARM:     /* R_ARM_NONE.  */
12931     case EM_C166:    /* R_XC16X_NONE.  */
12932     case EM_CRIS:    /* R_CRIS_NONE.  */
12933     case EM_FT32:    /* R_FT32_NONE.  */
12934     case EM_IA_64:   /* R_IA64_NONE.  */
12935     case EM_K1OM:    /* R_X86_64_NONE.  */
12936     case EM_L1OM:    /* R_X86_64_NONE.  */
12937     case EM_M32R:    /* R_M32R_NONE.  */
12938     case EM_MIPS:    /* R_MIPS_NONE.  */
12939     case EM_MN10300: /* R_MN10300_NONE.  */
12940     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12941     case EM_NIOS32:  /* R_NIOS_NONE.  */
12942     case EM_OR1K:    /* R_OR1K_NONE. */
12943     case EM_PARISC:  /* R_PARISC_NONE.  */
12944     case EM_PPC64:   /* R_PPC64_NONE.  */
12945     case EM_PPC:     /* R_PPC_NONE.  */
12946     case EM_RISCV:   /* R_RISCV_NONE.  */
12947     case EM_S390:    /* R_390_NONE.  */
12948     case EM_S390_OLD:
12949     case EM_SH:      /* R_SH_NONE.  */
12950     case EM_SPARC32PLUS:
12951     case EM_SPARC:   /* R_SPARC_NONE.  */
12952     case EM_SPARCV9:
12953     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12954     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12955     case EM_TI_C6000:/* R_C6000_NONE.  */
12956     case EM_X86_64:  /* R_X86_64_NONE.  */
12957     case EM_XC16X:
12958     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12959       return reloc_type == 0;
12960
12961     case EM_AARCH64:
12962       return reloc_type == 0 || reloc_type == 256;
12963     case EM_AVR_OLD:
12964     case EM_AVR:
12965       return (reloc_type == 0 /* R_AVR_NONE.  */
12966               || reloc_type == 30 /* R_AVR_DIFF8.  */
12967               || reloc_type == 31 /* R_AVR_DIFF16.  */
12968               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12969     case EM_METAG:
12970       return reloc_type == 3; /* R_METAG_NONE.  */
12971     case EM_NDS32:
12972       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12973               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12974               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12975               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12976               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12977     case EM_TI_PRU:
12978       return (reloc_type == 0       /* R_PRU_NONE.  */
12979               || reloc_type == 65   /* R_PRU_DIFF8.  */
12980               || reloc_type == 66   /* R_PRU_DIFF16.  */
12981               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12982     case EM_XTENSA_OLD:
12983     case EM_XTENSA:
12984       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12985               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12986               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12987               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12988     }
12989   return FALSE;
12990 }
12991
12992 /* Returns TRUE if there is a relocation against
12993    section NAME at OFFSET bytes.  */
12994
12995 bfd_boolean
12996 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12997 {
12998   Elf_Internal_Rela * relocs;
12999   Elf_Internal_Rela * rp;
13000
13001   if (dsec == NULL || dsec->reloc_info == NULL)
13002     return FALSE;
13003
13004   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13005
13006   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13007     if (rp->r_offset == offset)
13008       return TRUE;
13009
13010    return FALSE;
13011 }
13012
13013 /* Apply relocations to a section.
13014    Returns TRUE upon success, FALSE otherwise.
13015    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13016    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13017    will be set to the number of relocs loaded.
13018
13019    Note: So far support has been added only for those relocations
13020    which can be found in debug sections. FIXME: Add support for
13021    more relocations ?  */
13022
13023 static bfd_boolean
13024 apply_relocations (Filedata *                 filedata,
13025                    const Elf_Internal_Shdr *  section,
13026                    unsigned char *            start,
13027                    bfd_size_type              size,
13028                    void **                    relocs_return,
13029                    unsigned long *            num_relocs_return)
13030 {
13031   Elf_Internal_Shdr * relsec;
13032   unsigned char * end = start + size;
13033   bfd_boolean res = TRUE;
13034
13035   if (relocs_return != NULL)
13036     {
13037       * (Elf_Internal_Rela **) relocs_return = NULL;
13038       * num_relocs_return = 0;
13039     }
13040
13041   if (filedata->file_header.e_type != ET_REL)
13042     /* No relocs to apply.  */
13043     return TRUE;
13044
13045   /* Find the reloc section associated with the section.  */
13046   for (relsec = filedata->section_headers;
13047        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13048        ++relsec)
13049     {
13050       bfd_boolean is_rela;
13051       unsigned long num_relocs;
13052       Elf_Internal_Rela * relocs;
13053       Elf_Internal_Rela * rp;
13054       Elf_Internal_Shdr * symsec;
13055       Elf_Internal_Sym * symtab;
13056       unsigned long num_syms;
13057       Elf_Internal_Sym * sym;
13058
13059       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13060           || relsec->sh_info >= filedata->file_header.e_shnum
13061           || filedata->section_headers + relsec->sh_info != section
13062           || relsec->sh_size == 0
13063           || relsec->sh_link >= filedata->file_header.e_shnum)
13064         continue;
13065
13066       is_rela = relsec->sh_type == SHT_RELA;
13067
13068       if (is_rela)
13069         {
13070           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13071                                   relsec->sh_size, & relocs, & num_relocs))
13072             return FALSE;
13073         }
13074       else
13075         {
13076           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13077                                  relsec->sh_size, & relocs, & num_relocs))
13078             return FALSE;
13079         }
13080
13081       /* SH uses RELA but uses in place value instead of the addend field.  */
13082       if (filedata->file_header.e_machine == EM_SH)
13083         is_rela = FALSE;
13084
13085       symsec = filedata->section_headers + relsec->sh_link;
13086       if (symsec->sh_type != SHT_SYMTAB
13087           && symsec->sh_type != SHT_DYNSYM)
13088         return FALSE;
13089       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13090
13091       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13092         {
13093           bfd_vma         addend;
13094           unsigned int    reloc_type;
13095           unsigned int    reloc_size;
13096           bfd_boolean     reloc_inplace = FALSE;
13097           bfd_boolean     reloc_subtract = FALSE;
13098           unsigned char * rloc;
13099           unsigned long   sym_index;
13100
13101           reloc_type = get_reloc_type (filedata, rp->r_info);
13102
13103           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13104             continue;
13105           else if (is_none_reloc (filedata, reloc_type))
13106             continue;
13107           else if (is_32bit_abs_reloc (filedata, reloc_type)
13108                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13109             reloc_size = 4;
13110           else if (is_64bit_abs_reloc (filedata, reloc_type)
13111                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13112             reloc_size = 8;
13113           else if (is_24bit_abs_reloc (filedata, reloc_type))
13114             reloc_size = 3;
13115           else if (is_16bit_abs_reloc (filedata, reloc_type))
13116             reloc_size = 2;
13117           else if (is_8bit_abs_reloc (filedata, reloc_type)
13118                    || is_6bit_abs_reloc (filedata, reloc_type))
13119             reloc_size = 1;
13120           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13121                                                                  reloc_type))
13122                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13123             {
13124               reloc_size = 4;
13125               reloc_inplace = TRUE;
13126             }
13127           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13128                                                                  reloc_type))
13129                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13130             {
13131               reloc_size = 8;
13132               reloc_inplace = TRUE;
13133             }
13134           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13135                                                                  reloc_type))
13136                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13137             {
13138               reloc_size = 2;
13139               reloc_inplace = TRUE;
13140             }
13141           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13142                                                                 reloc_type))
13143                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13144             {
13145               reloc_size = 1;
13146               reloc_inplace = TRUE;
13147             }
13148           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13149                                                                 reloc_type)))
13150             {
13151               reloc_size = 1;
13152               reloc_inplace = TRUE;
13153             }
13154           else
13155             {
13156               static unsigned int prev_reloc = 0;
13157
13158               if (reloc_type != prev_reloc)
13159                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13160                       reloc_type, printable_section_name (filedata, section));
13161               prev_reloc = reloc_type;
13162               res = FALSE;
13163               continue;
13164             }
13165
13166           rloc = start + rp->r_offset;
13167           if ((rloc + reloc_size) > end || (rloc < start))
13168             {
13169               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13170                     (unsigned long) rp->r_offset,
13171                     printable_section_name (filedata, section));
13172               res = FALSE;
13173               continue;
13174             }
13175
13176           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13177           if (sym_index >= num_syms)
13178             {
13179               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13180                     sym_index, printable_section_name (filedata, section));
13181               res = FALSE;
13182               continue;
13183             }
13184           sym = symtab + sym_index;
13185
13186           /* If the reloc has a symbol associated with it,
13187              make sure that it is of an appropriate type.
13188
13189              Relocations against symbols without type can happen.
13190              Gcc -feliminate-dwarf2-dups may generate symbols
13191              without type for debug info.
13192
13193              Icc generates relocations against function symbols
13194              instead of local labels.
13195
13196              Relocations against object symbols can happen, eg when
13197              referencing a global array.  For an example of this see
13198              the _clz.o binary in libgcc.a.  */
13199           if (sym != symtab
13200               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13201               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13202             {
13203               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13204                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13205                     printable_section_name (filedata, relsec),
13206                     (long int)(rp - relocs));
13207               res = FALSE;
13208               continue;
13209             }
13210
13211           addend = 0;
13212           if (is_rela)
13213             addend += rp->r_addend;
13214           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13215              partial_inplace.  */
13216           if (!is_rela
13217               || (filedata->file_header.e_machine == EM_XTENSA
13218                   && reloc_type == 1)
13219               || ((filedata->file_header.e_machine == EM_PJ
13220                    || filedata->file_header.e_machine == EM_PJ_OLD)
13221                   && reloc_type == 1)
13222               || ((filedata->file_header.e_machine == EM_D30V
13223                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13224                   && reloc_type == 12)
13225               || reloc_inplace)
13226             {
13227               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13228                 addend += byte_get (rloc, reloc_size) & 0x3f;
13229               else
13230                 addend += byte_get (rloc, reloc_size);
13231             }
13232
13233           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13234               || is_64bit_pcrel_reloc (filedata, reloc_type))
13235             {
13236               /* On HPPA, all pc-relative relocations are biased by 8.  */
13237               if (filedata->file_header.e_machine == EM_PARISC)
13238                 addend -= 8;
13239               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13240                         reloc_size);
13241             }
13242           else if (is_6bit_abs_reloc (filedata, reloc_type)
13243                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13244             {
13245               if (reloc_subtract)
13246                 addend -= sym->st_value;
13247               else
13248                 addend += sym->st_value;
13249               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13250               byte_put (rloc, addend, reloc_size);
13251             }
13252           else if (reloc_subtract)
13253             byte_put (rloc, addend - sym->st_value, reloc_size);
13254           else
13255             byte_put (rloc, addend + sym->st_value, reloc_size);
13256         }
13257
13258       free (symtab);
13259       /* Let the target specific reloc processing code know that
13260          we have finished with these relocs.  */
13261       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13262
13263       if (relocs_return)
13264         {
13265           * (Elf_Internal_Rela **) relocs_return = relocs;
13266           * num_relocs_return = num_relocs;
13267         }
13268       else
13269         free (relocs);
13270
13271       break;
13272     }
13273
13274   return res;
13275 }
13276
13277 #ifdef SUPPORT_DISASSEMBLY
13278 static bfd_boolean
13279 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13280 {
13281   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13282
13283   /* FIXME: XXX -- to be done --- XXX */
13284
13285   return TRUE;
13286 }
13287 #endif
13288
13289 /* Reads in the contents of SECTION from FILE, returning a pointer
13290    to a malloc'ed buffer or NULL if something went wrong.  */
13291
13292 static char *
13293 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13294 {
13295   bfd_size_type num_bytes = section->sh_size;
13296
13297   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13298     {
13299       printf (_("Section '%s' has no data to dump.\n"),
13300               printable_section_name (filedata, section));
13301       return NULL;
13302     }
13303
13304   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13305                              _("section contents"));
13306 }
13307
13308 /* Uncompresses a section that was compressed using zlib, in place.  */
13309
13310 static bfd_boolean
13311 uncompress_section_contents (unsigned char **   buffer,
13312                              dwarf_size_type    uncompressed_size,
13313                              dwarf_size_type *  size)
13314 {
13315   dwarf_size_type compressed_size = *size;
13316   unsigned char * compressed_buffer = *buffer;
13317   unsigned char * uncompressed_buffer;
13318   z_stream strm;
13319   int rc;
13320
13321   /* It is possible the section consists of several compressed
13322      buffers concatenated together, so we uncompress in a loop.  */
13323   /* PR 18313: The state field in the z_stream structure is supposed
13324      to be invisible to the user (ie us), but some compilers will
13325      still complain about it being used without initialisation.  So
13326      we first zero the entire z_stream structure and then set the fields
13327      that we need.  */
13328   memset (& strm, 0, sizeof strm);
13329   strm.avail_in = compressed_size;
13330   strm.next_in = (Bytef *) compressed_buffer;
13331   strm.avail_out = uncompressed_size;
13332   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13333
13334   rc = inflateInit (& strm);
13335   while (strm.avail_in > 0)
13336     {
13337       if (rc != Z_OK)
13338         goto fail;
13339       strm.next_out = ((Bytef *) uncompressed_buffer
13340                        + (uncompressed_size - strm.avail_out));
13341       rc = inflate (&strm, Z_FINISH);
13342       if (rc != Z_STREAM_END)
13343         goto fail;
13344       rc = inflateReset (& strm);
13345     }
13346   rc = inflateEnd (& strm);
13347   if (rc != Z_OK
13348       || strm.avail_out != 0)
13349     goto fail;
13350
13351   *buffer = uncompressed_buffer;
13352   *size = uncompressed_size;
13353   return TRUE;
13354
13355  fail:
13356   free (uncompressed_buffer);
13357   /* Indicate decompression failure.  */
13358   *buffer = NULL;
13359   return FALSE;
13360 }
13361
13362 static bfd_boolean
13363 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13364 {
13365   Elf_Internal_Shdr *  relsec;
13366   bfd_size_type        num_bytes;
13367   unsigned char *      data;
13368   unsigned char *      end;
13369   unsigned char *      real_start;
13370   unsigned char *      start;
13371   bfd_boolean          some_strings_shown;
13372
13373   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13374   if (start == NULL)
13375     /* PR 21820: Do not fail if the section was empty.  */
13376     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13377
13378   num_bytes = section->sh_size;
13379
13380   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13381
13382   if (decompress_dumps)
13383     {
13384       dwarf_size_type new_size = num_bytes;
13385       dwarf_size_type uncompressed_size = 0;
13386
13387       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13388         {
13389           Elf_Internal_Chdr chdr;
13390           unsigned int compression_header_size
13391             = get_compression_header (& chdr, (unsigned char *) start,
13392                                       num_bytes);
13393
13394           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13395             {
13396               warn (_("section '%s' has unsupported compress type: %d\n"),
13397                     printable_section_name (filedata, section), chdr.ch_type);
13398               return FALSE;
13399             }
13400           else if (chdr.ch_addralign != section->sh_addralign)
13401             {
13402               warn (_("compressed section '%s' is corrupted\n"),
13403                     printable_section_name (filedata, section));
13404               return FALSE;
13405             }
13406           uncompressed_size = chdr.ch_size;
13407           start += compression_header_size;
13408           new_size -= compression_header_size;
13409         }
13410       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13411         {
13412           /* Read the zlib header.  In this case, it should be "ZLIB"
13413              followed by the uncompressed section size, 8 bytes in
13414              big-endian order.  */
13415           uncompressed_size = start[4]; uncompressed_size <<= 8;
13416           uncompressed_size += start[5]; uncompressed_size <<= 8;
13417           uncompressed_size += start[6]; uncompressed_size <<= 8;
13418           uncompressed_size += start[7]; uncompressed_size <<= 8;
13419           uncompressed_size += start[8]; uncompressed_size <<= 8;
13420           uncompressed_size += start[9]; uncompressed_size <<= 8;
13421           uncompressed_size += start[10]; uncompressed_size <<= 8;
13422           uncompressed_size += start[11];
13423           start += 12;
13424           new_size -= 12;
13425         }
13426
13427       if (uncompressed_size)
13428         {
13429           if (uncompress_section_contents (& start,
13430                                            uncompressed_size, & new_size))
13431             num_bytes = new_size;
13432           else
13433             {
13434               error (_("Unable to decompress section %s\n"),
13435                      printable_section_name (filedata, section));
13436               return FALSE;
13437             }
13438         }
13439       else
13440         start = real_start;
13441     }
13442
13443   /* If the section being dumped has relocations against it the user might
13444      be expecting these relocations to have been applied.  Check for this
13445      case and issue a warning message in order to avoid confusion.
13446      FIXME: Maybe we ought to have an option that dumps a section with
13447      relocs applied ?  */
13448   for (relsec = filedata->section_headers;
13449        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13450        ++relsec)
13451     {
13452       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13453           || relsec->sh_info >= filedata->file_header.e_shnum
13454           || filedata->section_headers + relsec->sh_info != section
13455           || relsec->sh_size == 0
13456           || relsec->sh_link >= filedata->file_header.e_shnum)
13457         continue;
13458
13459       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13460       break;
13461     }
13462
13463   data = start;
13464   end  = start + num_bytes;
13465   some_strings_shown = FALSE;
13466
13467   while (data < end)
13468     {
13469       while (!ISPRINT (* data))
13470         if (++ data >= end)
13471           break;
13472
13473       if (data < end)
13474         {
13475           size_t maxlen = end - data;
13476
13477 #ifndef __MSVCRT__
13478           /* PR 11128: Use two separate invocations in order to work
13479              around bugs in the Solaris 8 implementation of printf.  */
13480           printf ("  [%6tx]  ", data - start);
13481 #else
13482           printf ("  [%6Ix]  ", (size_t) (data - start));
13483 #endif
13484           if (maxlen > 0)
13485             {
13486               print_symbol ((int) maxlen, (const char *) data);
13487               putchar ('\n');
13488               data += strnlen ((const char *) data, maxlen);
13489             }
13490           else
13491             {
13492               printf (_("<corrupt>\n"));
13493               data = end;
13494             }
13495           some_strings_shown = TRUE;
13496         }
13497     }
13498
13499   if (! some_strings_shown)
13500     printf (_("  No strings found in this section."));
13501
13502   free (real_start);
13503
13504   putchar ('\n');
13505   return TRUE;
13506 }
13507
13508 static bfd_boolean
13509 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13510                        Filedata *           filedata,
13511                        bfd_boolean          relocate)
13512 {
13513   Elf_Internal_Shdr * relsec;
13514   bfd_size_type       bytes;
13515   bfd_size_type       section_size;
13516   bfd_vma             addr;
13517   unsigned char *     data;
13518   unsigned char *     real_start;
13519   unsigned char *     start;
13520
13521   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13522   if (start == NULL)
13523     /* PR 21820: Do not fail if the section was empty.  */
13524     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13525
13526   section_size = section->sh_size;
13527
13528   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13529
13530   if (decompress_dumps)
13531     {
13532       dwarf_size_type new_size = section_size;
13533       dwarf_size_type uncompressed_size = 0;
13534
13535       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13536         {
13537           Elf_Internal_Chdr chdr;
13538           unsigned int compression_header_size
13539             = get_compression_header (& chdr, start, section_size);
13540
13541           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13542             {
13543               warn (_("section '%s' has unsupported compress type: %d\n"),
13544                     printable_section_name (filedata, section), chdr.ch_type);
13545               return FALSE;
13546             }
13547           else if (chdr.ch_addralign != section->sh_addralign)
13548             {
13549               warn (_("compressed section '%s' is corrupted\n"),
13550                     printable_section_name (filedata, section));
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           else if (chdr.ch_addralign != sec->sh_addralign)
13723             {
13724               warn (_("compressed section '%s' is corrupted\n"),
13725                     section->name);
13726               return FALSE;
13727             }
13728           uncompressed_size = chdr.ch_size;
13729           start += compression_header_size;
13730           size -= compression_header_size;
13731         }
13732       else if (size > 12 && streq ((char *) start, "ZLIB"))
13733         {
13734           /* Read the zlib header.  In this case, it should be "ZLIB"
13735              followed by the uncompressed section size, 8 bytes in
13736              big-endian order.  */
13737           uncompressed_size = start[4]; uncompressed_size <<= 8;
13738           uncompressed_size += start[5]; uncompressed_size <<= 8;
13739           uncompressed_size += start[6]; uncompressed_size <<= 8;
13740           uncompressed_size += start[7]; uncompressed_size <<= 8;
13741           uncompressed_size += start[8]; uncompressed_size <<= 8;
13742           uncompressed_size += start[9]; uncompressed_size <<= 8;
13743           uncompressed_size += start[10]; uncompressed_size <<= 8;
13744           uncompressed_size += start[11];
13745           start += 12;
13746           size -= 12;
13747         }
13748
13749       if (uncompressed_size)
13750         {
13751           if (uncompress_section_contents (&start, uncompressed_size,
13752                                            &size))
13753             {
13754               /* Free the compressed buffer, update the section buffer
13755                  and the section size if uncompress is successful.  */
13756               free (section->start);
13757               section->start = start;
13758             }
13759           else
13760             {
13761               error (_("Unable to decompress section %s\n"),
13762                      printable_section_name (filedata, sec));
13763               return FALSE;
13764             }
13765         }
13766
13767       section->size = size;
13768     }
13769
13770   if (section->start == NULL)
13771     return FALSE;
13772
13773   if (debug_displays [debug].relocate)
13774     {
13775       if (! apply_relocations (filedata, sec, section->start, section->size,
13776                                & section->reloc_info, & section->num_relocs))
13777         return FALSE;
13778     }
13779   else
13780     {
13781       section->reloc_info = NULL;
13782       section->num_relocs = 0;
13783     }
13784
13785   return TRUE;
13786 }
13787
13788 /* If this is not NULL, load_debug_section will only look for sections
13789    within the list of sections given here.  */
13790 static unsigned int * section_subset = NULL;
13791
13792 bfd_boolean
13793 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13794 {
13795   struct dwarf_section * section = &debug_displays [debug].section;
13796   Elf_Internal_Shdr * sec;
13797   Filedata * filedata = (Filedata *) data;
13798
13799   /* Without section headers we cannot find any sections.  */
13800   if (filedata->section_headers == NULL)
13801     return FALSE;
13802
13803   if (filedata->string_table == NULL
13804       && filedata->file_header.e_shstrndx != SHN_UNDEF
13805       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13806     {
13807       Elf_Internal_Shdr * strs;
13808
13809       /* Read in the string table, so that we have section names to scan.  */
13810       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13811
13812       if (strs != NULL && strs->sh_size != 0)
13813         {
13814           filedata->string_table
13815             = (char *) get_data (NULL, filedata, strs->sh_offset,
13816                                  1, strs->sh_size, _("string table"));
13817
13818           filedata->string_table_length
13819             = filedata->string_table != NULL ? strs->sh_size : 0;
13820         }
13821     }
13822
13823   /* Locate the debug section.  */
13824   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13825   if (sec != NULL)
13826     section->name = section->uncompressed_name;
13827   else
13828     {
13829       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13830       if (sec != NULL)
13831         section->name = section->compressed_name;
13832     }
13833   if (sec == NULL)
13834     return FALSE;
13835
13836   /* If we're loading from a subset of sections, and we've loaded
13837      a section matching this name before, it's likely that it's a
13838      different one.  */
13839   if (section_subset != NULL)
13840     free_debug_section (debug);
13841
13842   return load_specific_debug_section (debug, sec, data);
13843 }
13844
13845 void
13846 free_debug_section (enum dwarf_section_display_enum debug)
13847 {
13848   struct dwarf_section * section = &debug_displays [debug].section;
13849
13850   if (section->start == NULL)
13851     return;
13852
13853   free ((char *) section->start);
13854   section->start = NULL;
13855   section->address = 0;
13856   section->size = 0;
13857 }
13858
13859 static bfd_boolean
13860 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13861 {
13862   char * name = SECTION_NAME (section);
13863   const char * print_name = printable_section_name (filedata, section);
13864   bfd_size_type length;
13865   bfd_boolean result = TRUE;
13866   int i;
13867
13868   length = section->sh_size;
13869   if (length == 0)
13870     {
13871       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13872       return TRUE;
13873     }
13874   if (section->sh_type == SHT_NOBITS)
13875     {
13876       /* There is no point in dumping the contents of a debugging section
13877          which has the NOBITS type - the bits in the file will be random.
13878          This can happen when a file containing a .eh_frame section is
13879          stripped with the --only-keep-debug command line option.  */
13880       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13881               print_name);
13882       return FALSE;
13883     }
13884
13885   if (const_strneq (name, ".gnu.linkonce.wi."))
13886     name = ".debug_info";
13887
13888   /* See if we know how to display the contents of this section.  */
13889   for (i = 0; i < max; i++)
13890     {
13891       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13892       struct dwarf_section_display *   display = debug_displays + i;
13893       struct dwarf_section *           sec = & display->section;
13894
13895       if (streq (sec->uncompressed_name, name)
13896           || (id == line && const_strneq (name, ".debug_line."))
13897           || streq (sec->compressed_name, name))
13898         {
13899           bfd_boolean secondary = (section != find_section (filedata, name));
13900
13901           if (secondary)
13902             free_debug_section (id);
13903
13904           if (i == line && const_strneq (name, ".debug_line."))
13905             sec->name = name;
13906           else if (streq (sec->uncompressed_name, name))
13907             sec->name = sec->uncompressed_name;
13908           else
13909             sec->name = sec->compressed_name;
13910
13911           if (load_specific_debug_section (id, section, filedata))
13912             {
13913               /* If this debug section is part of a CU/TU set in a .dwp file,
13914                  restrict load_debug_section to the sections in that set.  */
13915               section_subset = find_cu_tu_set (filedata, shndx);
13916
13917               result &= display->display (sec, filedata);
13918
13919               section_subset = NULL;
13920
13921               if (secondary || (id != info && id != abbrev))
13922                 free_debug_section (id);
13923             }
13924           break;
13925         }
13926     }
13927
13928   if (i == max)
13929     {
13930       printf (_("Unrecognized debug section: %s\n"), print_name);
13931       result = FALSE;
13932     }
13933
13934   return result;
13935 }
13936
13937 /* Set DUMP_SECTS for all sections where dumps were requested
13938    based on section name.  */
13939
13940 static void
13941 initialise_dumps_byname (Filedata * filedata)
13942 {
13943   struct dump_list_entry * cur;
13944
13945   for (cur = dump_sects_byname; cur; cur = cur->next)
13946     {
13947       unsigned int i;
13948       bfd_boolean any = FALSE;
13949
13950       for (i = 0; i < filedata->file_header.e_shnum; i++)
13951         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13952           {
13953             request_dump_bynumber (filedata, i, cur->type);
13954             any = TRUE;
13955           }
13956
13957       if (!any)
13958         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13959               cur->name);
13960     }
13961 }
13962
13963 static bfd_boolean
13964 process_section_contents (Filedata * filedata)
13965 {
13966   Elf_Internal_Shdr * section;
13967   unsigned int i;
13968   bfd_boolean res = TRUE;
13969
13970   if (! do_dump)
13971     return TRUE;
13972
13973   initialise_dumps_byname (filedata);
13974
13975   for (i = 0, section = filedata->section_headers;
13976        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13977        i++, section++)
13978     {
13979       dump_type dump = filedata->dump_sects[i];
13980
13981 #ifdef SUPPORT_DISASSEMBLY
13982       if (dump & DISASS_DUMP)
13983         {
13984           if (! disassemble_section (section, filedata))
13985             res = FALSE;
13986         }
13987 #endif
13988       if (dump & HEX_DUMP)
13989         {
13990           if (! dump_section_as_bytes (section, filedata, FALSE))
13991             res = FALSE;
13992         }
13993
13994       if (dump & RELOC_DUMP)
13995         {
13996           if (! dump_section_as_bytes (section, filedata, TRUE))
13997             res = FALSE;
13998         }
13999
14000       if (dump & STRING_DUMP)
14001         {
14002           if (! dump_section_as_strings (section, filedata))
14003             res = FALSE;
14004         }
14005
14006       if (dump & DEBUG_DUMP)
14007         {
14008           if (! display_debug_section (i, section, filedata))
14009             res = FALSE;
14010         }
14011     }
14012
14013   /* Check to see if the user requested a
14014      dump of a section that does not exist.  */
14015   while (i < filedata->num_dump_sects)
14016     {
14017       if (filedata->dump_sects[i])
14018         {
14019           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14020           res = FALSE;
14021         }
14022       i++;
14023     }
14024
14025   return res;
14026 }
14027
14028 static void
14029 process_mips_fpe_exception (int mask)
14030 {
14031   if (mask)
14032     {
14033       bfd_boolean first = TRUE;
14034
14035       if (mask & OEX_FPU_INEX)
14036         fputs ("INEX", stdout), first = FALSE;
14037       if (mask & OEX_FPU_UFLO)
14038         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14039       if (mask & OEX_FPU_OFLO)
14040         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14041       if (mask & OEX_FPU_DIV0)
14042         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14043       if (mask & OEX_FPU_INVAL)
14044         printf ("%sINVAL", first ? "" : "|");
14045     }
14046   else
14047     fputs ("0", stdout);
14048 }
14049
14050 /* Display's the value of TAG at location P.  If TAG is
14051    greater than 0 it is assumed to be an unknown tag, and
14052    a message is printed to this effect.  Otherwise it is
14053    assumed that a message has already been printed.
14054
14055    If the bottom bit of TAG is set it assumed to have a
14056    string value, otherwise it is assumed to have an integer
14057    value.
14058
14059    Returns an updated P pointing to the first unread byte
14060    beyond the end of TAG's value.
14061
14062    Reads at or beyond END will not be made.  */
14063
14064 static unsigned char *
14065 display_tag_value (signed int tag,
14066                    unsigned char * p,
14067                    const unsigned char * const end)
14068 {
14069   unsigned long val;
14070
14071   if (tag > 0)
14072     printf ("  Tag_unknown_%d: ", tag);
14073
14074   if (p >= end)
14075     {
14076       warn (_("<corrupt tag>\n"));
14077     }
14078   else if (tag & 1)
14079     {
14080       /* PR 17531 file: 027-19978-0.004.  */
14081       size_t maxlen = (end - p) - 1;
14082
14083       putchar ('"');
14084       if (maxlen > 0)
14085         {
14086           print_symbol ((int) maxlen, (const char *) p);
14087           p += strnlen ((char *) p, maxlen) + 1;
14088         }
14089       else
14090         {
14091           printf (_("<corrupt string tag>"));
14092           p = (unsigned char *) end;
14093         }
14094       printf ("\"\n");
14095     }
14096   else
14097     {
14098       unsigned int len;
14099
14100       val = read_uleb128 (p, &len, end);
14101       p += len;
14102       printf ("%ld (0x%lx)\n", val, val);
14103     }
14104
14105   assert (p <= end);
14106   return p;
14107 }
14108
14109 /* ARC ABI attributes section.  */
14110
14111 static unsigned char *
14112 display_arc_attribute (unsigned char * p,
14113                        const unsigned char * const end)
14114 {
14115   unsigned int tag;
14116   unsigned int len;
14117   unsigned int val;
14118
14119   tag = read_uleb128 (p, &len, end);
14120   p += len;
14121
14122   switch (tag)
14123     {
14124     case Tag_ARC_PCS_config:
14125       val = read_uleb128 (p, &len, end);
14126       p += len;
14127       printf ("  Tag_ARC_PCS_config: ");
14128       switch (val)
14129         {
14130         case 0:
14131           printf (_("Absent/Non standard\n"));
14132           break;
14133         case 1:
14134           printf (_("Bare metal/mwdt\n"));
14135           break;
14136         case 2:
14137           printf (_("Bare metal/newlib\n"));
14138           break;
14139         case 3:
14140           printf (_("Linux/uclibc\n"));
14141           break;
14142         case 4:
14143           printf (_("Linux/glibc\n"));
14144           break;
14145         default:
14146           printf (_("Unknown\n"));
14147           break;
14148         }
14149       break;
14150
14151     case Tag_ARC_CPU_base:
14152       val = read_uleb128 (p, &len, end);
14153       p += len;
14154       printf ("  Tag_ARC_CPU_base: ");
14155       switch (val)
14156         {
14157         default:
14158         case TAG_CPU_NONE:
14159           printf (_("Absent\n"));
14160           break;
14161         case TAG_CPU_ARC6xx:
14162           printf ("ARC6xx\n");
14163           break;
14164         case TAG_CPU_ARC7xx:
14165           printf ("ARC7xx\n");
14166           break;
14167         case TAG_CPU_ARCEM:
14168           printf ("ARCEM\n");
14169           break;
14170         case TAG_CPU_ARCHS:
14171           printf ("ARCHS\n");
14172           break;
14173         }
14174       break;
14175
14176     case Tag_ARC_CPU_variation:
14177       val = read_uleb128 (p, &len, end);
14178       p += len;
14179       printf ("  Tag_ARC_CPU_variation: ");
14180       switch (val)
14181         {
14182         default:
14183           if (val > 0 && val < 16)
14184               printf ("Core%d\n", val);
14185           else
14186               printf ("Unknown\n");
14187           break;
14188
14189         case 0:
14190           printf (_("Absent\n"));
14191           break;
14192         }
14193       break;
14194
14195     case Tag_ARC_CPU_name:
14196       printf ("  Tag_ARC_CPU_name: ");
14197       p = display_tag_value (-1, p, end);
14198       break;
14199
14200     case Tag_ARC_ABI_rf16:
14201       val = read_uleb128 (p, &len, end);
14202       p += len;
14203       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14204       break;
14205
14206     case Tag_ARC_ABI_osver:
14207       val = read_uleb128 (p, &len, end);
14208       p += len;
14209       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14210       break;
14211
14212     case Tag_ARC_ABI_pic:
14213     case Tag_ARC_ABI_sda:
14214       val = read_uleb128 (p, &len, end);
14215       p += len;
14216       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14217               : "  Tag_ARC_ABI_pic: ");
14218       switch (val)
14219         {
14220         case 0:
14221           printf (_("Absent\n"));
14222           break;
14223         case 1:
14224           printf ("MWDT\n");
14225           break;
14226         case 2:
14227           printf ("GNU\n");
14228           break;
14229         default:
14230           printf (_("Unknown\n"));
14231           break;
14232         }
14233       break;
14234
14235     case Tag_ARC_ABI_tls:
14236       val = read_uleb128 (p, &len, end);
14237       p += len;
14238       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14239       break;
14240
14241     case Tag_ARC_ABI_enumsize:
14242       val = read_uleb128 (p, &len, end);
14243       p += len;
14244       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14245               _("smallest"));
14246       break;
14247
14248     case Tag_ARC_ABI_exceptions:
14249       val = read_uleb128 (p, &len, end);
14250       p += len;
14251       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14252               : _("default"));
14253       break;
14254
14255     case Tag_ARC_ABI_double_size:
14256       val = read_uleb128 (p, &len, end);
14257       p += len;
14258       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14259       break;
14260
14261     case Tag_ARC_ISA_config:
14262       printf ("  Tag_ARC_ISA_config: ");
14263       p = display_tag_value (-1, p, end);
14264       break;
14265
14266     case Tag_ARC_ISA_apex:
14267       printf ("  Tag_ARC_ISA_apex: ");
14268       p = display_tag_value (-1, p, end);
14269       break;
14270
14271     case Tag_ARC_ISA_mpy_option:
14272       val = read_uleb128 (p, &len, end);
14273       p += len;
14274       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14275       break;
14276
14277     case Tag_ARC_ATR_version:
14278       val = read_uleb128 (p, &len, end);
14279       p += len;
14280       printf ("  Tag_ARC_ATR_version: %d\n", val);
14281       break;
14282
14283     default:
14284       return display_tag_value (tag & 1, p, end);
14285     }
14286
14287   return p;
14288 }
14289
14290 /* ARM EABI attributes section.  */
14291 typedef struct
14292 {
14293   unsigned int tag;
14294   const char * name;
14295   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14296   unsigned int type;
14297   const char ** table;
14298 } arm_attr_public_tag;
14299
14300 static const char * arm_attr_tag_CPU_arch[] =
14301   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14302    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14303    "v8-M.mainline"};
14304 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14305 static const char * arm_attr_tag_THUMB_ISA_use[] =
14306   {"No", "Thumb-1", "Thumb-2", "Yes"};
14307 static const char * arm_attr_tag_FP_arch[] =
14308   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14309    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14310 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14311 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14312   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14313    "NEON for ARMv8.1"};
14314 static const char * arm_attr_tag_PCS_config[] =
14315   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14316    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14317 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14318   {"V6", "SB", "TLS", "Unused"};
14319 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14320   {"Absolute", "PC-relative", "SB-relative", "None"};
14321 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14322   {"Absolute", "PC-relative", "None"};
14323 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14324   {"None", "direct", "GOT-indirect"};
14325 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14326   {"None", "??? 1", "2", "??? 3", "4"};
14327 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14328 static const char * arm_attr_tag_ABI_FP_denormal[] =
14329   {"Unused", "Needed", "Sign only"};
14330 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14331 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14332 static const char * arm_attr_tag_ABI_FP_number_model[] =
14333   {"Unused", "Finite", "RTABI", "IEEE 754"};
14334 static const char * arm_attr_tag_ABI_enum_size[] =
14335   {"Unused", "small", "int", "forced to int"};
14336 static const char * arm_attr_tag_ABI_HardFP_use[] =
14337   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14338 static const char * arm_attr_tag_ABI_VFP_args[] =
14339   {"AAPCS", "VFP registers", "custom", "compatible"};
14340 static const char * arm_attr_tag_ABI_WMMX_args[] =
14341   {"AAPCS", "WMMX registers", "custom"};
14342 static const char * arm_attr_tag_ABI_optimization_goals[] =
14343   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14344     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14345 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14346   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14347     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14348 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14349 static const char * arm_attr_tag_FP_HP_extension[] =
14350   {"Not Allowed", "Allowed"};
14351 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14352   {"None", "IEEE 754", "Alternative Format"};
14353 static const char * arm_attr_tag_DSP_extension[] =
14354   {"Follow architecture", "Allowed"};
14355 static const char * arm_attr_tag_MPextension_use[] =
14356   {"Not Allowed", "Allowed"};
14357 static const char * arm_attr_tag_DIV_use[] =
14358   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14359     "Allowed in v7-A with integer division extension"};
14360 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14361 static const char * arm_attr_tag_Virtualization_use[] =
14362   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14363     "TrustZone and Virtualization Extensions"};
14364 static const char * arm_attr_tag_MPextension_use_legacy[] =
14365   {"Not Allowed", "Allowed"};
14366
14367 #define LOOKUP(id, name) \
14368   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14369 static arm_attr_public_tag arm_attr_public_tags[] =
14370 {
14371   {4, "CPU_raw_name", 1, NULL},
14372   {5, "CPU_name", 1, NULL},
14373   LOOKUP(6, CPU_arch),
14374   {7, "CPU_arch_profile", 0, NULL},
14375   LOOKUP(8, ARM_ISA_use),
14376   LOOKUP(9, THUMB_ISA_use),
14377   LOOKUP(10, FP_arch),
14378   LOOKUP(11, WMMX_arch),
14379   LOOKUP(12, Advanced_SIMD_arch),
14380   LOOKUP(13, PCS_config),
14381   LOOKUP(14, ABI_PCS_R9_use),
14382   LOOKUP(15, ABI_PCS_RW_data),
14383   LOOKUP(16, ABI_PCS_RO_data),
14384   LOOKUP(17, ABI_PCS_GOT_use),
14385   LOOKUP(18, ABI_PCS_wchar_t),
14386   LOOKUP(19, ABI_FP_rounding),
14387   LOOKUP(20, ABI_FP_denormal),
14388   LOOKUP(21, ABI_FP_exceptions),
14389   LOOKUP(22, ABI_FP_user_exceptions),
14390   LOOKUP(23, ABI_FP_number_model),
14391   {24, "ABI_align_needed", 0, NULL},
14392   {25, "ABI_align_preserved", 0, NULL},
14393   LOOKUP(26, ABI_enum_size),
14394   LOOKUP(27, ABI_HardFP_use),
14395   LOOKUP(28, ABI_VFP_args),
14396   LOOKUP(29, ABI_WMMX_args),
14397   LOOKUP(30, ABI_optimization_goals),
14398   LOOKUP(31, ABI_FP_optimization_goals),
14399   {32, "compatibility", 0, NULL},
14400   LOOKUP(34, CPU_unaligned_access),
14401   LOOKUP(36, FP_HP_extension),
14402   LOOKUP(38, ABI_FP_16bit_format),
14403   LOOKUP(42, MPextension_use),
14404   LOOKUP(44, DIV_use),
14405   LOOKUP(46, DSP_extension),
14406   {64, "nodefaults", 0, NULL},
14407   {65, "also_compatible_with", 0, NULL},
14408   LOOKUP(66, T2EE_use),
14409   {67, "conformance", 1, NULL},
14410   LOOKUP(68, Virtualization_use),
14411   LOOKUP(70, MPextension_use_legacy)
14412 };
14413 #undef LOOKUP
14414
14415 static unsigned char *
14416 display_arm_attribute (unsigned char * p,
14417                        const unsigned char * const end)
14418 {
14419   unsigned int tag;
14420   unsigned int len;
14421   unsigned int val;
14422   arm_attr_public_tag * attr;
14423   unsigned i;
14424   unsigned int type;
14425
14426   tag = read_uleb128 (p, &len, end);
14427   p += len;
14428   attr = NULL;
14429   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14430     {
14431       if (arm_attr_public_tags[i].tag == tag)
14432         {
14433           attr = &arm_attr_public_tags[i];
14434           break;
14435         }
14436     }
14437
14438   if (attr)
14439     {
14440       printf ("  Tag_%s: ", attr->name);
14441       switch (attr->type)
14442         {
14443         case 0:
14444           switch (tag)
14445             {
14446             case 7: /* Tag_CPU_arch_profile.  */
14447               val = read_uleb128 (p, &len, end);
14448               p += len;
14449               switch (val)
14450                 {
14451                 case 0: printf (_("None\n")); break;
14452                 case 'A': printf (_("Application\n")); break;
14453                 case 'R': printf (_("Realtime\n")); break;
14454                 case 'M': printf (_("Microcontroller\n")); break;
14455                 case 'S': printf (_("Application or Realtime\n")); break;
14456                 default: printf ("??? (%d)\n", val); break;
14457                 }
14458               break;
14459
14460             case 24: /* Tag_align_needed.  */
14461               val = read_uleb128 (p, &len, end);
14462               p += len;
14463               switch (val)
14464                 {
14465                 case 0: printf (_("None\n")); break;
14466                 case 1: printf (_("8-byte\n")); break;
14467                 case 2: printf (_("4-byte\n")); break;
14468                 case 3: printf ("??? 3\n"); break;
14469                 default:
14470                   if (val <= 12)
14471                     printf (_("8-byte and up to %d-byte extended\n"),
14472                             1 << val);
14473                   else
14474                     printf ("??? (%d)\n", val);
14475                   break;
14476                 }
14477               break;
14478
14479             case 25: /* Tag_align_preserved.  */
14480               val = read_uleb128 (p, &len, end);
14481               p += len;
14482               switch (val)
14483                 {
14484                 case 0: printf (_("None\n")); break;
14485                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14486                 case 2: printf (_("8-byte\n")); break;
14487                 case 3: printf ("??? 3\n"); break;
14488                 default:
14489                   if (val <= 12)
14490                     printf (_("8-byte and up to %d-byte extended\n"),
14491                             1 << val);
14492                   else
14493                     printf ("??? (%d)\n", val);
14494                   break;
14495                 }
14496               break;
14497
14498             case 32: /* Tag_compatibility.  */
14499               {
14500                 val = read_uleb128 (p, &len, end);
14501                 p += len;
14502                 printf (_("flag = %d, vendor = "), val);
14503                 if (p < end - 1)
14504                   {
14505                     size_t maxlen = (end - p) - 1;
14506
14507                     print_symbol ((int) maxlen, (const char *) p);
14508                     p += strnlen ((char *) p, maxlen) + 1;
14509                   }
14510                 else
14511                   {
14512                     printf (_("<corrupt>"));
14513                     p = (unsigned char *) end;
14514                   }
14515                 putchar ('\n');
14516               }
14517               break;
14518
14519             case 64: /* Tag_nodefaults.  */
14520               /* PR 17531: file: 001-505008-0.01.  */
14521               if (p < end)
14522                 p++;
14523               printf (_("True\n"));
14524               break;
14525
14526             case 65: /* Tag_also_compatible_with.  */
14527               val = read_uleb128 (p, &len, end);
14528               p += len;
14529               if (val == 6 /* Tag_CPU_arch.  */)
14530                 {
14531                   val = read_uleb128 (p, &len, end);
14532                   p += len;
14533                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14534                     printf ("??? (%d)\n", val);
14535                   else
14536                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14537                 }
14538               else
14539                 printf ("???\n");
14540               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14541                 ;
14542               break;
14543
14544             default:
14545               printf (_("<unknown: %d>\n"), tag);
14546               break;
14547             }
14548           return p;
14549
14550         case 1:
14551           return display_tag_value (-1, p, end);
14552         case 2:
14553           return display_tag_value (0, p, end);
14554
14555         default:
14556           assert (attr->type & 0x80);
14557           val = read_uleb128 (p, &len, end);
14558           p += len;
14559           type = attr->type & 0x7f;
14560           if (val >= type)
14561             printf ("??? (%d)\n", val);
14562           else
14563             printf ("%s\n", attr->table[val]);
14564           return p;
14565         }
14566     }
14567
14568   return display_tag_value (tag, p, end);
14569 }
14570
14571 static unsigned char *
14572 display_gnu_attribute (unsigned char * p,
14573                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14574                        const unsigned char * const end)
14575 {
14576   int tag;
14577   unsigned int len;
14578   unsigned int val;
14579
14580   tag = read_uleb128 (p, &len, end);
14581   p += len;
14582
14583   /* Tag_compatibility is the only generic GNU attribute defined at
14584      present.  */
14585   if (tag == 32)
14586     {
14587       val = read_uleb128 (p, &len, end);
14588       p += len;
14589
14590       printf (_("flag = %d, vendor = "), val);
14591       if (p == end)
14592         {
14593           printf (_("<corrupt>\n"));
14594           warn (_("corrupt vendor attribute\n"));
14595         }
14596       else
14597         {
14598           if (p < end - 1)
14599             {
14600               size_t maxlen = (end - p) - 1;
14601
14602               print_symbol ((int) maxlen, (const char *) p);
14603               p += strnlen ((char *) p, maxlen) + 1;
14604             }
14605           else
14606             {
14607               printf (_("<corrupt>"));
14608               p = (unsigned char *) end;
14609             }
14610           putchar ('\n');
14611         }
14612       return p;
14613     }
14614
14615   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14616     return display_proc_gnu_attribute (p, tag, end);
14617
14618   return display_tag_value (tag, p, end);
14619 }
14620
14621 static unsigned char *
14622 display_power_gnu_attribute (unsigned char * p,
14623                              unsigned int tag,
14624                              const unsigned char * const end)
14625 {
14626   unsigned int len;
14627   unsigned int val;
14628
14629   if (tag == Tag_GNU_Power_ABI_FP)
14630     {
14631       val = read_uleb128 (p, &len, end);
14632       p += len;
14633       printf ("  Tag_GNU_Power_ABI_FP: ");
14634       if (len == 0)
14635         {
14636           printf (_("<corrupt>\n"));
14637           return p;
14638         }
14639
14640       if (val > 15)
14641         printf ("(%#x), ", val);
14642
14643       switch (val & 3)
14644         {
14645         case 0:
14646           printf (_("unspecified hard/soft float, "));
14647           break;
14648         case 1:
14649           printf (_("hard float, "));
14650           break;
14651         case 2:
14652           printf (_("soft float, "));
14653           break;
14654         case 3:
14655           printf (_("single-precision hard float, "));
14656           break;
14657         }
14658
14659       switch (val & 0xC)
14660         {
14661         case 0:
14662           printf (_("unspecified long double\n"));
14663           break;
14664         case 4:
14665           printf (_("128-bit IBM long double\n"));
14666           break;
14667         case 8:
14668           printf (_("64-bit long double\n"));
14669           break;
14670         case 12:
14671           printf (_("128-bit IEEE long double\n"));
14672           break;
14673         }
14674       return p;
14675     }
14676
14677   if (tag == Tag_GNU_Power_ABI_Vector)
14678     {
14679       val = read_uleb128 (p, &len, end);
14680       p += len;
14681       printf ("  Tag_GNU_Power_ABI_Vector: ");
14682       if (len == 0)
14683         {
14684           printf (_("<corrupt>\n"));
14685           return p;
14686         }
14687
14688       if (val > 3)
14689         printf ("(%#x), ", val);
14690
14691       switch (val & 3)
14692         {
14693         case 0:
14694           printf (_("unspecified\n"));
14695           break;
14696         case 1:
14697           printf (_("generic\n"));
14698           break;
14699         case 2:
14700           printf ("AltiVec\n");
14701           break;
14702         case 3:
14703           printf ("SPE\n");
14704           break;
14705         }
14706       return p;
14707     }
14708
14709   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14710     {
14711       val = read_uleb128 (p, &len, end);
14712       p += len;
14713       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14714       if (len == 0)
14715         {
14716           printf (_("<corrupt>\n"));
14717           return p;
14718         }
14719
14720       if (val > 2)
14721         printf ("(%#x), ", val);
14722
14723       switch (val & 3)
14724         {
14725         case 0:
14726           printf (_("unspecified\n"));
14727           break;
14728         case 1:
14729           printf ("r3/r4\n");
14730           break;
14731         case 2:
14732           printf (_("memory\n"));
14733           break;
14734         case 3:
14735           printf ("???\n");
14736           break;
14737         }
14738       return p;
14739     }
14740
14741   return display_tag_value (tag & 1, p, end);
14742 }
14743
14744 static unsigned char *
14745 display_s390_gnu_attribute (unsigned char * p,
14746                             unsigned int tag,
14747                             const unsigned char * const end)
14748 {
14749   unsigned int len;
14750   int val;
14751
14752   if (tag == Tag_GNU_S390_ABI_Vector)
14753     {
14754       val = read_uleb128 (p, &len, end);
14755       p += len;
14756       printf ("  Tag_GNU_S390_ABI_Vector: ");
14757
14758       switch (val)
14759         {
14760         case 0:
14761           printf (_("any\n"));
14762           break;
14763         case 1:
14764           printf (_("software\n"));
14765           break;
14766         case 2:
14767           printf (_("hardware\n"));
14768           break;
14769         default:
14770           printf ("??? (%d)\n", val);
14771           break;
14772         }
14773       return p;
14774    }
14775
14776   return display_tag_value (tag & 1, p, end);
14777 }
14778
14779 static void
14780 display_sparc_hwcaps (unsigned int mask)
14781 {
14782   if (mask)
14783     {
14784       bfd_boolean first = TRUE;
14785
14786       if (mask & ELF_SPARC_HWCAP_MUL32)
14787         fputs ("mul32", stdout), first = FALSE;
14788       if (mask & ELF_SPARC_HWCAP_DIV32)
14789         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14790       if (mask & ELF_SPARC_HWCAP_FSMULD)
14791         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14792       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14793         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14794       if (mask & ELF_SPARC_HWCAP_POPC)
14795         printf ("%spopc", first ? "" : "|"), first = FALSE;
14796       if (mask & ELF_SPARC_HWCAP_VIS)
14797         printf ("%svis", first ? "" : "|"), first = FALSE;
14798       if (mask & ELF_SPARC_HWCAP_VIS2)
14799         printf ("%svis2", first ? "" : "|"), first = FALSE;
14800       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14801         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14802       if (mask & ELF_SPARC_HWCAP_FMAF)
14803         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14804       if (mask & ELF_SPARC_HWCAP_VIS3)
14805         printf ("%svis3", first ? "" : "|"), first = FALSE;
14806       if (mask & ELF_SPARC_HWCAP_HPC)
14807         printf ("%shpc", first ? "" : "|"), first = FALSE;
14808       if (mask & ELF_SPARC_HWCAP_RANDOM)
14809         printf ("%srandom", first ? "" : "|"), first = FALSE;
14810       if (mask & ELF_SPARC_HWCAP_TRANS)
14811         printf ("%strans", first ? "" : "|"), first = FALSE;
14812       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14813         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14814       if (mask & ELF_SPARC_HWCAP_IMA)
14815         printf ("%sima", first ? "" : "|"), first = FALSE;
14816       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14817         printf ("%scspare", first ? "" : "|"), first = FALSE;
14818     }
14819   else
14820     fputc ('0', stdout);
14821   fputc ('\n', stdout);
14822 }
14823
14824 static void
14825 display_sparc_hwcaps2 (unsigned int mask)
14826 {
14827   if (mask)
14828     {
14829       bfd_boolean first = TRUE;
14830
14831       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14832         fputs ("fjathplus", stdout), first = FALSE;
14833       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14834         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14835       if (mask & ELF_SPARC_HWCAP2_ADP)
14836         printf ("%sadp", first ? "" : "|"), first = FALSE;
14837       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14838         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14839       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14840         printf ("%smwait", first ? "" : "|"), first = FALSE;
14841       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14842         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14843       if (mask & ELF_SPARC_HWCAP2_XMONT)
14844         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14845       if (mask & ELF_SPARC_HWCAP2_NSEC)
14846         printf ("%snsec", first ? "" : "|"), first = FALSE;
14847       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14848         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14849       if (mask & ELF_SPARC_HWCAP2_FJDES)
14850         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14851       if (mask & ELF_SPARC_HWCAP2_FJAES)
14852         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14853     }
14854   else
14855     fputc ('0', stdout);
14856   fputc ('\n', stdout);
14857 }
14858
14859 static unsigned char *
14860 display_sparc_gnu_attribute (unsigned char * p,
14861                              unsigned int tag,
14862                              const unsigned char * const end)
14863 {
14864   unsigned int len;
14865   int val;
14866
14867   if (tag == Tag_GNU_Sparc_HWCAPS)
14868     {
14869       val = read_uleb128 (p, &len, end);
14870       p += len;
14871       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14872       display_sparc_hwcaps (val);
14873       return p;
14874     }
14875   if (tag == Tag_GNU_Sparc_HWCAPS2)
14876     {
14877       val = read_uleb128 (p, &len, end);
14878       p += len;
14879       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14880       display_sparc_hwcaps2 (val);
14881       return p;
14882     }
14883
14884   return display_tag_value (tag, p, end);
14885 }
14886
14887 static void
14888 print_mips_fp_abi_value (unsigned int val)
14889 {
14890   switch (val)
14891     {
14892     case Val_GNU_MIPS_ABI_FP_ANY:
14893       printf (_("Hard or soft float\n"));
14894       break;
14895     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14896       printf (_("Hard float (double precision)\n"));
14897       break;
14898     case Val_GNU_MIPS_ABI_FP_SINGLE:
14899       printf (_("Hard float (single precision)\n"));
14900       break;
14901     case Val_GNU_MIPS_ABI_FP_SOFT:
14902       printf (_("Soft float\n"));
14903       break;
14904     case Val_GNU_MIPS_ABI_FP_OLD_64:
14905       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14906       break;
14907     case Val_GNU_MIPS_ABI_FP_XX:
14908       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14909       break;
14910     case Val_GNU_MIPS_ABI_FP_64:
14911       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14912       break;
14913     case Val_GNU_MIPS_ABI_FP_64A:
14914       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14915       break;
14916     case Val_GNU_MIPS_ABI_FP_NAN2008:
14917       printf (_("NaN 2008 compatibility\n"));
14918       break;
14919     default:
14920       printf ("??? (%d)\n", val);
14921       break;
14922     }
14923 }
14924
14925 static unsigned char *
14926 display_mips_gnu_attribute (unsigned char * p,
14927                             unsigned int tag,
14928                             const unsigned char * const end)
14929 {
14930   if (tag == Tag_GNU_MIPS_ABI_FP)
14931     {
14932       unsigned int len;
14933       unsigned int val;
14934
14935       val = read_uleb128 (p, &len, end);
14936       p += len;
14937       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14938
14939       print_mips_fp_abi_value (val);
14940
14941       return p;
14942    }
14943
14944   if (tag == Tag_GNU_MIPS_ABI_MSA)
14945     {
14946       unsigned int len;
14947       unsigned int val;
14948
14949       val = read_uleb128 (p, &len, end);
14950       p += len;
14951       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14952
14953       switch (val)
14954         {
14955         case Val_GNU_MIPS_ABI_MSA_ANY:
14956           printf (_("Any MSA or not\n"));
14957           break;
14958         case Val_GNU_MIPS_ABI_MSA_128:
14959           printf (_("128-bit MSA\n"));
14960           break;
14961         default:
14962           printf ("??? (%d)\n", val);
14963           break;
14964         }
14965       return p;
14966     }
14967
14968   return display_tag_value (tag & 1, p, end);
14969 }
14970
14971 static unsigned char *
14972 display_tic6x_attribute (unsigned char * p,
14973                          const unsigned char * const end)
14974 {
14975   unsigned int tag;
14976   unsigned int len;
14977   int val;
14978
14979   tag = read_uleb128 (p, &len, end);
14980   p += len;
14981
14982   switch (tag)
14983     {
14984     case Tag_ISA:
14985       val = read_uleb128 (p, &len, end);
14986       p += len;
14987       printf ("  Tag_ISA: ");
14988
14989       switch (val)
14990         {
14991         case C6XABI_Tag_ISA_none:
14992           printf (_("None\n"));
14993           break;
14994         case C6XABI_Tag_ISA_C62X:
14995           printf ("C62x\n");
14996           break;
14997         case C6XABI_Tag_ISA_C67X:
14998           printf ("C67x\n");
14999           break;
15000         case C6XABI_Tag_ISA_C67XP:
15001           printf ("C67x+\n");
15002           break;
15003         case C6XABI_Tag_ISA_C64X:
15004           printf ("C64x\n");
15005           break;
15006         case C6XABI_Tag_ISA_C64XP:
15007           printf ("C64x+\n");
15008           break;
15009         case C6XABI_Tag_ISA_C674X:
15010           printf ("C674x\n");
15011           break;
15012         default:
15013           printf ("??? (%d)\n", val);
15014           break;
15015         }
15016       return p;
15017
15018     case Tag_ABI_wchar_t:
15019       val = read_uleb128 (p, &len, end);
15020       p += len;
15021       printf ("  Tag_ABI_wchar_t: ");
15022       switch (val)
15023         {
15024         case 0:
15025           printf (_("Not used\n"));
15026           break;
15027         case 1:
15028           printf (_("2 bytes\n"));
15029           break;
15030         case 2:
15031           printf (_("4 bytes\n"));
15032           break;
15033         default:
15034           printf ("??? (%d)\n", val);
15035           break;
15036         }
15037       return p;
15038
15039     case Tag_ABI_stack_align_needed:
15040       val = read_uleb128 (p, &len, end);
15041       p += len;
15042       printf ("  Tag_ABI_stack_align_needed: ");
15043       switch (val)
15044         {
15045         case 0:
15046           printf (_("8-byte\n"));
15047           break;
15048         case 1:
15049           printf (_("16-byte\n"));
15050           break;
15051         default:
15052           printf ("??? (%d)\n", val);
15053           break;
15054         }
15055       return p;
15056
15057     case Tag_ABI_stack_align_preserved:
15058       val = read_uleb128 (p, &len, end);
15059       p += len;
15060       printf ("  Tag_ABI_stack_align_preserved: ");
15061       switch (val)
15062         {
15063         case 0:
15064           printf (_("8-byte\n"));
15065           break;
15066         case 1:
15067           printf (_("16-byte\n"));
15068           break;
15069         default:
15070           printf ("??? (%d)\n", val);
15071           break;
15072         }
15073       return p;
15074
15075     case Tag_ABI_DSBT:
15076       val = read_uleb128 (p, &len, end);
15077       p += len;
15078       printf ("  Tag_ABI_DSBT: ");
15079       switch (val)
15080         {
15081         case 0:
15082           printf (_("DSBT addressing not used\n"));
15083           break;
15084         case 1:
15085           printf (_("DSBT addressing used\n"));
15086           break;
15087         default:
15088           printf ("??? (%d)\n", val);
15089           break;
15090         }
15091       return p;
15092
15093     case Tag_ABI_PID:
15094       val = read_uleb128 (p, &len, end);
15095       p += len;
15096       printf ("  Tag_ABI_PID: ");
15097       switch (val)
15098         {
15099         case 0:
15100           printf (_("Data addressing position-dependent\n"));
15101           break;
15102         case 1:
15103           printf (_("Data addressing position-independent, GOT near DP\n"));
15104           break;
15105         case 2:
15106           printf (_("Data addressing position-independent, GOT far from DP\n"));
15107           break;
15108         default:
15109           printf ("??? (%d)\n", val);
15110           break;
15111         }
15112       return p;
15113
15114     case Tag_ABI_PIC:
15115       val = read_uleb128 (p, &len, end);
15116       p += len;
15117       printf ("  Tag_ABI_PIC: ");
15118       switch (val)
15119         {
15120         case 0:
15121           printf (_("Code addressing position-dependent\n"));
15122           break;
15123         case 1:
15124           printf (_("Code addressing position-independent\n"));
15125           break;
15126         default:
15127           printf ("??? (%d)\n", val);
15128           break;
15129         }
15130       return p;
15131
15132     case Tag_ABI_array_object_alignment:
15133       val = read_uleb128 (p, &len, end);
15134       p += len;
15135       printf ("  Tag_ABI_array_object_alignment: ");
15136       switch (val)
15137         {
15138         case 0:
15139           printf (_("8-byte\n"));
15140           break;
15141         case 1:
15142           printf (_("4-byte\n"));
15143           break;
15144         case 2:
15145           printf (_("16-byte\n"));
15146           break;
15147         default:
15148           printf ("??? (%d)\n", val);
15149           break;
15150         }
15151       return p;
15152
15153     case Tag_ABI_array_object_align_expected:
15154       val = read_uleb128 (p, &len, end);
15155       p += len;
15156       printf ("  Tag_ABI_array_object_align_expected: ");
15157       switch (val)
15158         {
15159         case 0:
15160           printf (_("8-byte\n"));
15161           break;
15162         case 1:
15163           printf (_("4-byte\n"));
15164           break;
15165         case 2:
15166           printf (_("16-byte\n"));
15167           break;
15168         default:
15169           printf ("??? (%d)\n", val);
15170           break;
15171         }
15172       return p;
15173
15174     case Tag_ABI_compatibility:
15175       {
15176         val = read_uleb128 (p, &len, end);
15177         p += len;
15178         printf ("  Tag_ABI_compatibility: ");
15179         printf (_("flag = %d, vendor = "), val);
15180         if (p < end - 1)
15181           {
15182             size_t maxlen = (end - p) - 1;
15183
15184             print_symbol ((int) maxlen, (const char *) p);
15185             p += strnlen ((char *) p, maxlen) + 1;
15186           }
15187         else
15188           {
15189             printf (_("<corrupt>"));
15190             p = (unsigned char *) end;
15191           }
15192         putchar ('\n');
15193         return p;
15194       }
15195
15196     case Tag_ABI_conformance:
15197       {
15198         printf ("  Tag_ABI_conformance: \"");
15199         if (p < end - 1)
15200           {
15201             size_t maxlen = (end - p) - 1;
15202
15203             print_symbol ((int) maxlen, (const char *) p);
15204             p += strnlen ((char *) p, maxlen) + 1;
15205           }
15206         else
15207           {
15208             printf (_("<corrupt>"));
15209             p = (unsigned char *) end;
15210           }
15211         printf ("\"\n");
15212         return p;
15213       }
15214     }
15215
15216   return display_tag_value (tag, p, end);
15217 }
15218
15219 static void
15220 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15221 {
15222   unsigned long addr = 0;
15223   size_t bytes = end - p;
15224
15225   assert (end > p);
15226   while (bytes)
15227     {
15228       int j;
15229       int k;
15230       int lbytes = (bytes > 16 ? 16 : bytes);
15231
15232       printf ("  0x%8.8lx ", addr);
15233
15234       for (j = 0; j < 16; j++)
15235         {
15236           if (j < lbytes)
15237             printf ("%2.2x", p[j]);
15238           else
15239             printf ("  ");
15240
15241           if ((j & 3) == 3)
15242             printf (" ");
15243         }
15244
15245       for (j = 0; j < lbytes; j++)
15246         {
15247           k = p[j];
15248           if (k >= ' ' && k < 0x7f)
15249             printf ("%c", k);
15250           else
15251             printf (".");
15252         }
15253
15254       putchar ('\n');
15255
15256       p  += lbytes;
15257       bytes -= lbytes;
15258       addr += lbytes;
15259     }
15260
15261   putchar ('\n');
15262 }
15263
15264 static unsigned char *
15265 display_msp430x_attribute (unsigned char * p,
15266                            const unsigned char * const end)
15267 {
15268   unsigned int len;
15269   unsigned int val;
15270   unsigned int tag;
15271
15272   tag = read_uleb128 (p, & len, end);
15273   p += len;
15274
15275   switch (tag)
15276     {
15277     case OFBA_MSPABI_Tag_ISA:
15278       val = read_uleb128 (p, &len, end);
15279       p += len;
15280       printf ("  Tag_ISA: ");
15281       switch (val)
15282         {
15283         case 0: printf (_("None\n")); break;
15284         case 1: printf (_("MSP430\n")); break;
15285         case 2: printf (_("MSP430X\n")); break;
15286         default: printf ("??? (%d)\n", val); break;
15287         }
15288       break;
15289
15290     case OFBA_MSPABI_Tag_Code_Model:
15291       val = read_uleb128 (p, &len, end);
15292       p += len;
15293       printf ("  Tag_Code_Model: ");
15294       switch (val)
15295         {
15296         case 0: printf (_("None\n")); break;
15297         case 1: printf (_("Small\n")); break;
15298         case 2: printf (_("Large\n")); break;
15299         default: printf ("??? (%d)\n", val); break;
15300         }
15301       break;
15302
15303     case OFBA_MSPABI_Tag_Data_Model:
15304       val = read_uleb128 (p, &len, end);
15305       p += len;
15306       printf ("  Tag_Data_Model: ");
15307       switch (val)
15308         {
15309         case 0: printf (_("None\n")); break;
15310         case 1: printf (_("Small\n")); break;
15311         case 2: printf (_("Large\n")); break;
15312         case 3: printf (_("Restricted Large\n")); break;
15313         default: printf ("??? (%d)\n", val); break;
15314         }
15315       break;
15316
15317     default:
15318       printf (_("  <unknown tag %d>: "), tag);
15319
15320       if (tag & 1)
15321         {
15322           putchar ('"');
15323           if (p < end - 1)
15324             {
15325               size_t maxlen = (end - p) - 1;
15326
15327               print_symbol ((int) maxlen, (const char *) p);
15328               p += strnlen ((char *) p, maxlen) + 1;
15329             }
15330           else
15331             {
15332               printf (_("<corrupt>"));
15333               p = (unsigned char *) end;
15334             }
15335           printf ("\"\n");
15336         }
15337       else
15338         {
15339           val = read_uleb128 (p, &len, end);
15340           p += len;
15341           printf ("%d (0x%x)\n", val, val);
15342         }
15343       break;
15344    }
15345
15346   assert (p <= end);
15347   return p;
15348 }
15349
15350 static bfd_boolean
15351 process_attributes (Filedata * filedata,
15352                     const char * public_name,
15353                     unsigned int proc_type,
15354                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15355                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15356 {
15357   Elf_Internal_Shdr * sect;
15358   unsigned i;
15359   bfd_boolean res = TRUE;
15360
15361   /* Find the section header so that we get the size.  */
15362   for (i = 0, sect = filedata->section_headers;
15363        i < filedata->file_header.e_shnum;
15364        i++, sect++)
15365     {
15366       unsigned char * contents;
15367       unsigned char * p;
15368
15369       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15370         continue;
15371
15372       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15373                                              sect->sh_size, _("attributes"));
15374       if (contents == NULL)
15375         {
15376           res = FALSE;
15377           continue;
15378         }
15379
15380       p = contents;
15381       /* The first character is the version of the attributes.
15382          Currently only version 1, (aka 'A') is recognised here.  */
15383       if (*p != 'A')
15384         {
15385           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15386           res = FALSE;
15387         }
15388       else
15389         {
15390           bfd_vma section_len;
15391
15392           section_len = sect->sh_size - 1;
15393           p++;
15394
15395           while (section_len > 0)
15396             {
15397               bfd_vma attr_len;
15398               unsigned int namelen;
15399               bfd_boolean public_section;
15400               bfd_boolean gnu_section;
15401
15402               if (section_len <= 4)
15403                 {
15404                   error (_("Tag section ends prematurely\n"));
15405                   res = FALSE;
15406                   break;
15407                 }
15408               attr_len = byte_get (p, 4);
15409               p += 4;
15410
15411               if (attr_len > section_len)
15412                 {
15413                   error (_("Bad attribute length (%u > %u)\n"),
15414                           (unsigned) attr_len, (unsigned) section_len);
15415                   attr_len = section_len;
15416                   res = FALSE;
15417                 }
15418               /* PR 17531: file: 001-101425-0.004  */
15419               else if (attr_len < 5)
15420                 {
15421                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15422                   res = FALSE;
15423                   break;
15424                 }
15425
15426               section_len -= attr_len;
15427               attr_len -= 4;
15428
15429               namelen = strnlen ((char *) p, attr_len) + 1;
15430               if (namelen == 0 || namelen >= attr_len)
15431                 {
15432                   error (_("Corrupt attribute section name\n"));
15433                   res = FALSE;
15434                   break;
15435                 }
15436
15437               printf (_("Attribute Section: "));
15438               print_symbol (INT_MAX, (const char *) p);
15439               putchar ('\n');
15440
15441               if (public_name && streq ((char *) p, public_name))
15442                 public_section = TRUE;
15443               else
15444                 public_section = FALSE;
15445
15446               if (streq ((char *) p, "gnu"))
15447                 gnu_section = TRUE;
15448               else
15449                 gnu_section = FALSE;
15450
15451               p += namelen;
15452               attr_len -= namelen;
15453
15454               while (attr_len > 0 && p < contents + sect->sh_size)
15455                 {
15456                   int tag;
15457                   int val;
15458                   bfd_vma size;
15459                   unsigned char * end;
15460
15461                   /* PR binutils/17531: Safe handling of corrupt files.  */
15462                   if (attr_len < 6)
15463                     {
15464                       error (_("Unused bytes at end of section\n"));
15465                       res = FALSE;
15466                       section_len = 0;
15467                       break;
15468                     }
15469
15470                   tag = *(p++);
15471                   size = byte_get (p, 4);
15472                   if (size > attr_len)
15473                     {
15474                       error (_("Bad subsection length (%u > %u)\n"),
15475                               (unsigned) size, (unsigned) attr_len);
15476                       res = FALSE;
15477                       size = attr_len;
15478                     }
15479                   /* PR binutils/17531: Safe handling of corrupt files.  */
15480                   if (size < 6)
15481                     {
15482                       error (_("Bad subsection length (%u < 6)\n"),
15483                               (unsigned) size);
15484                       res = FALSE;
15485                       section_len = 0;
15486                       break;
15487                     }
15488
15489                   attr_len -= size;
15490                   end = p + size - 1;
15491                   assert (end <= contents + sect->sh_size);
15492                   p += 4;
15493
15494                   switch (tag)
15495                     {
15496                     case 1:
15497                       printf (_("File Attributes\n"));
15498                       break;
15499                     case 2:
15500                       printf (_("Section Attributes:"));
15501                       goto do_numlist;
15502                     case 3:
15503                       printf (_("Symbol Attributes:"));
15504                       /* Fall through.  */
15505                     do_numlist:
15506                       for (;;)
15507                         {
15508                           unsigned int j;
15509
15510                           val = read_uleb128 (p, &j, end);
15511                           p += j;
15512                           if (val == 0)
15513                             break;
15514                           printf (" %d", val);
15515                         }
15516                       printf ("\n");
15517                       break;
15518                     default:
15519                       printf (_("Unknown tag: %d\n"), tag);
15520                       public_section = FALSE;
15521                       break;
15522                     }
15523
15524                   if (public_section && display_pub_attribute != NULL)
15525                     {
15526                       while (p < end)
15527                         p = display_pub_attribute (p, end);
15528                       assert (p == end);
15529                     }
15530                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15531                     {
15532                       while (p < end)
15533                         p = display_gnu_attribute (p,
15534                                                    display_proc_gnu_attribute,
15535                                                    end);
15536                       assert (p == end);
15537                     }
15538                   else if (p < end)
15539                     {
15540                       printf (_("  Unknown attribute:\n"));
15541                       display_raw_attribute (p, end);
15542                       p = end;
15543                     }
15544                   else
15545                     attr_len = 0;
15546                 }
15547             }
15548         }
15549
15550       free (contents);
15551     }
15552
15553   return res;
15554 }
15555
15556 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15557    Print the Address, Access and Initial fields of an entry at VMA ADDR
15558    and return the VMA of the next entry, or -1 if there was a problem.
15559    Does not read from DATA_END or beyond.  */
15560
15561 static bfd_vma
15562 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15563                       unsigned char * data_end)
15564 {
15565   printf ("  ");
15566   print_vma (addr, LONG_HEX);
15567   printf (" ");
15568   if (addr < pltgot + 0xfff0)
15569     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15570   else
15571     printf ("%10s", "");
15572   printf (" ");
15573   if (data == NULL)
15574     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15575   else
15576     {
15577       bfd_vma entry;
15578       unsigned char * from = data + addr - pltgot;
15579
15580       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15581         {
15582           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15583           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15584           return (bfd_vma) -1;
15585         }
15586       else
15587         {
15588           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15589           print_vma (entry, LONG_HEX);
15590         }
15591     }
15592   return addr + (is_32bit_elf ? 4 : 8);
15593 }
15594
15595 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15596    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15597    ADDR and return the VMA of the next entry.  */
15598
15599 static bfd_vma
15600 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15601 {
15602   printf ("  ");
15603   print_vma (addr, LONG_HEX);
15604   printf (" ");
15605   if (data == NULL)
15606     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15607   else
15608     {
15609       bfd_vma entry;
15610
15611       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15612       print_vma (entry, LONG_HEX);
15613     }
15614   return addr + (is_32bit_elf ? 4 : 8);
15615 }
15616
15617 static void
15618 print_mips_ases (unsigned int mask)
15619 {
15620   if (mask & AFL_ASE_DSP)
15621     fputs ("\n\tDSP ASE", stdout);
15622   if (mask & AFL_ASE_DSPR2)
15623     fputs ("\n\tDSP R2 ASE", stdout);
15624   if (mask & AFL_ASE_DSPR3)
15625     fputs ("\n\tDSP R3 ASE", stdout);
15626   if (mask & AFL_ASE_EVA)
15627     fputs ("\n\tEnhanced VA Scheme", stdout);
15628   if (mask & AFL_ASE_MCU)
15629     fputs ("\n\tMCU (MicroController) ASE", stdout);
15630   if (mask & AFL_ASE_MDMX)
15631     fputs ("\n\tMDMX ASE", stdout);
15632   if (mask & AFL_ASE_MIPS3D)
15633     fputs ("\n\tMIPS-3D ASE", stdout);
15634   if (mask & AFL_ASE_MT)
15635     fputs ("\n\tMT ASE", stdout);
15636   if (mask & AFL_ASE_SMARTMIPS)
15637     fputs ("\n\tSmartMIPS ASE", stdout);
15638   if (mask & AFL_ASE_VIRT)
15639     fputs ("\n\tVZ ASE", stdout);
15640   if (mask & AFL_ASE_MSA)
15641     fputs ("\n\tMSA ASE", stdout);
15642   if (mask & AFL_ASE_MIPS16)
15643     fputs ("\n\tMIPS16 ASE", stdout);
15644   if (mask & AFL_ASE_MICROMIPS)
15645     fputs ("\n\tMICROMIPS ASE", stdout);
15646   if (mask & AFL_ASE_XPA)
15647     fputs ("\n\tXPA ASE", stdout);
15648   if (mask & AFL_ASE_MIPS16E2)
15649     fputs ("\n\tMIPS16e2 ASE", stdout);
15650   if (mask & AFL_ASE_CRC)
15651     fputs ("\n\tCRC ASE", stdout);
15652   if (mask & AFL_ASE_GINV)
15653     fputs ("\n\tGINV ASE", stdout);
15654   if (mask & AFL_ASE_LOONGSON_MMI)
15655     fputs ("\n\tLoongson MMI ASE", stdout);
15656   if (mask & AFL_ASE_LOONGSON_CAM)
15657     fputs ("\n\tLoongson CAM ASE", stdout);
15658   if (mask & AFL_ASE_LOONGSON_EXT)
15659     fputs ("\n\tLoongson EXT ASE", stdout);
15660   if (mask & AFL_ASE_LOONGSON_EXT2)
15661     fputs ("\n\tLoongson EXT2 ASE", stdout);
15662   if (mask == 0)
15663     fprintf (stdout, "\n\t%s", _("None"));
15664   else if ((mask & ~AFL_ASE_MASK) != 0)
15665     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15666 }
15667
15668 static void
15669 print_mips_isa_ext (unsigned int isa_ext)
15670 {
15671   switch (isa_ext)
15672     {
15673     case 0:
15674       fputs (_("None"), stdout);
15675       break;
15676     case AFL_EXT_XLR:
15677       fputs ("RMI XLR", stdout);
15678       break;
15679     case AFL_EXT_OCTEON3:
15680       fputs ("Cavium Networks Octeon3", stdout);
15681       break;
15682     case AFL_EXT_OCTEON2:
15683       fputs ("Cavium Networks Octeon2", stdout);
15684       break;
15685     case AFL_EXT_OCTEONP:
15686       fputs ("Cavium Networks OcteonP", stdout);
15687       break;
15688     case AFL_EXT_OCTEON:
15689       fputs ("Cavium Networks Octeon", stdout);
15690       break;
15691     case AFL_EXT_5900:
15692       fputs ("Toshiba R5900", stdout);
15693       break;
15694     case AFL_EXT_4650:
15695       fputs ("MIPS R4650", stdout);
15696       break;
15697     case AFL_EXT_4010:
15698       fputs ("LSI R4010", stdout);
15699       break;
15700     case AFL_EXT_4100:
15701       fputs ("NEC VR4100", stdout);
15702       break;
15703     case AFL_EXT_3900:
15704       fputs ("Toshiba R3900", stdout);
15705       break;
15706     case AFL_EXT_10000:
15707       fputs ("MIPS R10000", stdout);
15708       break;
15709     case AFL_EXT_SB1:
15710       fputs ("Broadcom SB-1", stdout);
15711       break;
15712     case AFL_EXT_4111:
15713       fputs ("NEC VR4111/VR4181", stdout);
15714       break;
15715     case AFL_EXT_4120:
15716       fputs ("NEC VR4120", stdout);
15717       break;
15718     case AFL_EXT_5400:
15719       fputs ("NEC VR5400", stdout);
15720       break;
15721     case AFL_EXT_5500:
15722       fputs ("NEC VR5500", stdout);
15723       break;
15724     case AFL_EXT_LOONGSON_2E:
15725       fputs ("ST Microelectronics Loongson 2E", stdout);
15726       break;
15727     case AFL_EXT_LOONGSON_2F:
15728       fputs ("ST Microelectronics Loongson 2F", stdout);
15729       break;
15730     case AFL_EXT_INTERAPTIV_MR2:
15731       fputs ("Imagination interAptiv MR2", stdout);
15732       break;
15733     default:
15734       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15735     }
15736 }
15737
15738 static signed int
15739 get_mips_reg_size (int reg_size)
15740 {
15741   return (reg_size == AFL_REG_NONE) ? 0
15742          : (reg_size == AFL_REG_32) ? 32
15743          : (reg_size == AFL_REG_64) ? 64
15744          : (reg_size == AFL_REG_128) ? 128
15745          : -1;
15746 }
15747
15748 static bfd_boolean
15749 process_mips_specific (Filedata * filedata)
15750 {
15751   Elf_Internal_Dyn * entry;
15752   Elf_Internal_Shdr *sect = NULL;
15753   size_t liblist_offset = 0;
15754   size_t liblistno = 0;
15755   size_t conflictsno = 0;
15756   size_t options_offset = 0;
15757   size_t conflicts_offset = 0;
15758   size_t pltrelsz = 0;
15759   size_t pltrel = 0;
15760   bfd_vma pltgot = 0;
15761   bfd_vma mips_pltgot = 0;
15762   bfd_vma jmprel = 0;
15763   bfd_vma local_gotno = 0;
15764   bfd_vma gotsym = 0;
15765   bfd_vma symtabno = 0;
15766   bfd_boolean res = TRUE;
15767
15768   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15769                             display_mips_gnu_attribute))
15770     res = FALSE;
15771
15772   sect = find_section (filedata, ".MIPS.abiflags");
15773
15774   if (sect != NULL)
15775     {
15776       Elf_External_ABIFlags_v0 *abiflags_ext;
15777       Elf_Internal_ABIFlags_v0 abiflags_in;
15778
15779       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15780         {
15781           error (_("Corrupt MIPS ABI Flags section.\n"));
15782           res = FALSE;
15783         }
15784       else
15785         {
15786           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15787                                    sect->sh_size, _("MIPS ABI Flags section"));
15788           if (abiflags_ext)
15789             {
15790               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15791               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15792               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15793               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15794               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15795               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15796               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15797               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15798               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15799               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15800               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15801
15802               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15803               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15804               if (abiflags_in.isa_rev > 1)
15805                 printf ("r%d", abiflags_in.isa_rev);
15806               printf ("\nGPR size: %d",
15807                       get_mips_reg_size (abiflags_in.gpr_size));
15808               printf ("\nCPR1 size: %d",
15809                       get_mips_reg_size (abiflags_in.cpr1_size));
15810               printf ("\nCPR2 size: %d",
15811                       get_mips_reg_size (abiflags_in.cpr2_size));
15812               fputs ("\nFP ABI: ", stdout);
15813               print_mips_fp_abi_value (abiflags_in.fp_abi);
15814               fputs ("ISA Extension: ", stdout);
15815               print_mips_isa_ext (abiflags_in.isa_ext);
15816               fputs ("\nASEs:", stdout);
15817               print_mips_ases (abiflags_in.ases);
15818               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15819               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15820               fputc ('\n', stdout);
15821               free (abiflags_ext);
15822             }
15823         }
15824     }
15825
15826   /* We have a lot of special sections.  Thanks SGI!  */
15827   if (dynamic_section == NULL)
15828     {
15829       /* No dynamic information available.  See if there is static GOT.  */
15830       sect = find_section (filedata, ".got");
15831       if (sect != NULL)
15832         {
15833           unsigned char *data_end;
15834           unsigned char *data;
15835           bfd_vma ent, end;
15836           int addr_size;
15837
15838           pltgot = sect->sh_addr;
15839
15840           ent = pltgot;
15841           addr_size = (is_32bit_elf ? 4 : 8);
15842           end = pltgot + sect->sh_size;
15843
15844           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15845                                              end - pltgot, 1,
15846                                              _("Global Offset Table data"));
15847           /* PR 12855: Null data is handled gracefully throughout.  */
15848           data_end = data + (end - pltgot);
15849
15850           printf (_("\nStatic GOT:\n"));
15851           printf (_(" Canonical gp value: "));
15852           print_vma (ent + 0x7ff0, LONG_HEX);
15853           printf ("\n\n");
15854
15855           /* In a dynamic binary GOT[0] is reserved for the dynamic
15856              loader to store the lazy resolver pointer, however in
15857              a static binary it may well have been omitted and GOT
15858              reduced to a table of addresses.
15859              PR 21344: Check for the entry being fully available
15860              before fetching it.  */
15861           if (data
15862               && data + ent - pltgot + addr_size <= data_end
15863               && byte_get (data + ent - pltgot, addr_size) == 0)
15864             {
15865               printf (_(" Reserved entries:\n"));
15866               printf (_("  %*s %10s %*s\n"),
15867                       addr_size * 2, _("Address"), _("Access"),
15868                       addr_size * 2, _("Value"));
15869               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15870               printf ("\n");
15871               if (ent == (bfd_vma) -1)
15872                 goto sgot_print_fail;
15873
15874               /* Check for the MSB of GOT[1] being set, identifying a
15875                  GNU object.  This entry will be used by some runtime
15876                  loaders, to store the module pointer.  Otherwise this
15877                  is an ordinary local entry.
15878                  PR 21344: Check for the entry being fully available
15879                  before fetching it.  */
15880               if (data
15881                   && data + ent - pltgot + addr_size <= data_end
15882                   && (byte_get (data + ent - pltgot, addr_size)
15883                       >> (addr_size * 8 - 1)) != 0)
15884                 {
15885                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15886                   printf ("\n");
15887                   if (ent == (bfd_vma) -1)
15888                     goto sgot_print_fail;
15889                 }
15890               printf ("\n");
15891             }
15892
15893           if (data != NULL && ent < end)
15894             {
15895               printf (_(" Local entries:\n"));
15896               printf ("  %*s %10s %*s\n",
15897                       addr_size * 2, _("Address"), _("Access"),
15898                       addr_size * 2, _("Value"));
15899               while (ent < end)
15900                 {
15901                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15902                   printf ("\n");
15903                   if (ent == (bfd_vma) -1)
15904                     goto sgot_print_fail;
15905                 }
15906               printf ("\n");
15907             }
15908
15909         sgot_print_fail:
15910           if (data)
15911             free (data);
15912         }
15913       return res;
15914     }
15915
15916   for (entry = dynamic_section;
15917        /* PR 17531 file: 012-50589-0.004.  */
15918        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15919        ++entry)
15920     switch (entry->d_tag)
15921       {
15922       case DT_MIPS_LIBLIST:
15923         liblist_offset
15924           = offset_from_vma (filedata, entry->d_un.d_val,
15925                              liblistno * sizeof (Elf32_External_Lib));
15926         break;
15927       case DT_MIPS_LIBLISTNO:
15928         liblistno = entry->d_un.d_val;
15929         break;
15930       case DT_MIPS_OPTIONS:
15931         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15932         break;
15933       case DT_MIPS_CONFLICT:
15934         conflicts_offset
15935           = offset_from_vma (filedata, entry->d_un.d_val,
15936                              conflictsno * sizeof (Elf32_External_Conflict));
15937         break;
15938       case DT_MIPS_CONFLICTNO:
15939         conflictsno = entry->d_un.d_val;
15940         break;
15941       case DT_PLTGOT:
15942         pltgot = entry->d_un.d_ptr;
15943         break;
15944       case DT_MIPS_LOCAL_GOTNO:
15945         local_gotno = entry->d_un.d_val;
15946         break;
15947       case DT_MIPS_GOTSYM:
15948         gotsym = entry->d_un.d_val;
15949         break;
15950       case DT_MIPS_SYMTABNO:
15951         symtabno = entry->d_un.d_val;
15952         break;
15953       case DT_MIPS_PLTGOT:
15954         mips_pltgot = entry->d_un.d_ptr;
15955         break;
15956       case DT_PLTREL:
15957         pltrel = entry->d_un.d_val;
15958         break;
15959       case DT_PLTRELSZ:
15960         pltrelsz = entry->d_un.d_val;
15961         break;
15962       case DT_JMPREL:
15963         jmprel = entry->d_un.d_ptr;
15964         break;
15965       default:
15966         break;
15967       }
15968
15969   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15970     {
15971       Elf32_External_Lib * elib;
15972       size_t cnt;
15973
15974       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15975                                               liblistno,
15976                                               sizeof (Elf32_External_Lib),
15977                                               _("liblist section data"));
15978       if (elib)
15979         {
15980           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15981                             "\nSection '.liblist' contains %lu entries:\n",
15982                             (unsigned long) liblistno),
15983                   (unsigned long) liblistno);
15984           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15985                  stdout);
15986
15987           for (cnt = 0; cnt < liblistno; ++cnt)
15988             {
15989               Elf32_Lib liblist;
15990               time_t atime;
15991               char timebuf[128];
15992               struct tm * tmp;
15993
15994               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15995               atime = BYTE_GET (elib[cnt].l_time_stamp);
15996               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15997               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15998               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15999
16000               tmp = gmtime (&atime);
16001               snprintf (timebuf, sizeof (timebuf),
16002                         "%04u-%02u-%02uT%02u:%02u:%02u",
16003                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16004                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16005
16006               printf ("%3lu: ", (unsigned long) cnt);
16007               if (VALID_DYNAMIC_NAME (liblist.l_name))
16008                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16009               else
16010                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16011               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16012                       liblist.l_version);
16013
16014               if (liblist.l_flags == 0)
16015                 puts (_(" NONE"));
16016               else
16017                 {
16018                   static const struct
16019                   {
16020                     const char * name;
16021                     int bit;
16022                   }
16023                   l_flags_vals[] =
16024                   {
16025                     { " EXACT_MATCH", LL_EXACT_MATCH },
16026                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16027                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16028                     { " EXPORTS", LL_EXPORTS },
16029                     { " DELAY_LOAD", LL_DELAY_LOAD },
16030                     { " DELTA", LL_DELTA }
16031                   };
16032                   int flags = liblist.l_flags;
16033                   size_t fcnt;
16034
16035                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16036                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16037                       {
16038                         fputs (l_flags_vals[fcnt].name, stdout);
16039                         flags ^= l_flags_vals[fcnt].bit;
16040                       }
16041                   if (flags != 0)
16042                     printf (" %#x", (unsigned int) flags);
16043
16044                   puts ("");
16045                 }
16046             }
16047
16048           free (elib);
16049         }
16050       else
16051         res = FALSE;
16052     }
16053
16054   if (options_offset != 0)
16055     {
16056       Elf_External_Options * eopt;
16057       Elf_Internal_Options * iopt;
16058       Elf_Internal_Options * option;
16059       size_t offset;
16060       int cnt;
16061       sect = filedata->section_headers;
16062
16063       /* Find the section header so that we get the size.  */
16064       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16065       /* PR 17533 file: 012-277276-0.004.  */
16066       if (sect == NULL)
16067         {
16068           error (_("No MIPS_OPTIONS header found\n"));
16069           return FALSE;
16070         }
16071
16072       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16073                                                 sect->sh_size, _("options"));
16074       if (eopt)
16075         {
16076           iopt = (Elf_Internal_Options *)
16077               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16078           if (iopt == NULL)
16079             {
16080               error (_("Out of memory allocating space for MIPS options\n"));
16081               return FALSE;
16082             }
16083
16084           offset = cnt = 0;
16085           option = iopt;
16086
16087           while (offset <= sect->sh_size - sizeof (* eopt))
16088             {
16089               Elf_External_Options * eoption;
16090
16091               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16092
16093               option->kind = BYTE_GET (eoption->kind);
16094               option->size = BYTE_GET (eoption->size);
16095               option->section = BYTE_GET (eoption->section);
16096               option->info = BYTE_GET (eoption->info);
16097
16098               /* PR 17531: file: ffa0fa3b.  */
16099               if (option->size < sizeof (* eopt)
16100                   || offset + option->size > sect->sh_size)
16101                 {
16102                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16103                   return FALSE;
16104                 }
16105               offset += option->size;
16106
16107               ++option;
16108               ++cnt;
16109             }
16110
16111           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16112                             "\nSection '%s' contains %d entries:\n",
16113                             cnt),
16114                   printable_section_name (filedata, sect), cnt);
16115
16116           option = iopt;
16117           offset = 0;
16118
16119           while (cnt-- > 0)
16120             {
16121               size_t len;
16122
16123               switch (option->kind)
16124                 {
16125                 case ODK_NULL:
16126                   /* This shouldn't happen.  */
16127                   printf (" NULL       %d %lx", option->section, option->info);
16128                   break;
16129                 case ODK_REGINFO:
16130                   printf (" REGINFO    ");
16131                   if (filedata->file_header.e_machine == EM_MIPS)
16132                     {
16133                       /* 32bit form.  */
16134                       Elf32_External_RegInfo * ereg;
16135                       Elf32_RegInfo reginfo;
16136
16137                       ereg = (Elf32_External_RegInfo *) (option + 1);
16138                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16139                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16140                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16141                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16142                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16143                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16144
16145                       printf ("GPR %08lx  GP 0x%lx\n",
16146                               reginfo.ri_gprmask,
16147                               (unsigned long) reginfo.ri_gp_value);
16148                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16149                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16150                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16151                     }
16152                   else
16153                     {
16154                       /* 64 bit form.  */
16155                       Elf64_External_RegInfo * ereg;
16156                       Elf64_Internal_RegInfo reginfo;
16157
16158                       ereg = (Elf64_External_RegInfo *) (option + 1);
16159                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16160                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16161                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16162                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16163                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16164                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16165
16166                       printf ("GPR %08lx  GP 0x",
16167                               reginfo.ri_gprmask);
16168                       printf_vma (reginfo.ri_gp_value);
16169                       printf ("\n");
16170
16171                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16172                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16173                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16174                     }
16175                   ++option;
16176                   continue;
16177                 case ODK_EXCEPTIONS:
16178                   fputs (" EXCEPTIONS fpe_min(", stdout);
16179                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16180                   fputs (") fpe_max(", stdout);
16181                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16182                   fputs (")", stdout);
16183
16184                   if (option->info & OEX_PAGE0)
16185                     fputs (" PAGE0", stdout);
16186                   if (option->info & OEX_SMM)
16187                     fputs (" SMM", stdout);
16188                   if (option->info & OEX_FPDBUG)
16189                     fputs (" FPDBUG", stdout);
16190                   if (option->info & OEX_DISMISS)
16191                     fputs (" DISMISS", stdout);
16192                   break;
16193                 case ODK_PAD:
16194                   fputs (" PAD       ", stdout);
16195                   if (option->info & OPAD_PREFIX)
16196                     fputs (" PREFIX", stdout);
16197                   if (option->info & OPAD_POSTFIX)
16198                     fputs (" POSTFIX", stdout);
16199                   if (option->info & OPAD_SYMBOL)
16200                     fputs (" SYMBOL", stdout);
16201                   break;
16202                 case ODK_HWPATCH:
16203                   fputs (" HWPATCH   ", stdout);
16204                   if (option->info & OHW_R4KEOP)
16205                     fputs (" R4KEOP", stdout);
16206                   if (option->info & OHW_R8KPFETCH)
16207                     fputs (" R8KPFETCH", stdout);
16208                   if (option->info & OHW_R5KEOP)
16209                     fputs (" R5KEOP", stdout);
16210                   if (option->info & OHW_R5KCVTL)
16211                     fputs (" R5KCVTL", stdout);
16212                   break;
16213                 case ODK_FILL:
16214                   fputs (" FILL       ", stdout);
16215                   /* XXX Print content of info word?  */
16216                   break;
16217                 case ODK_TAGS:
16218                   fputs (" TAGS       ", stdout);
16219                   /* XXX Print content of info word?  */
16220                   break;
16221                 case ODK_HWAND:
16222                   fputs (" HWAND     ", stdout);
16223                   if (option->info & OHWA0_R4KEOP_CHECKED)
16224                     fputs (" R4KEOP_CHECKED", stdout);
16225                   if (option->info & OHWA0_R4KEOP_CLEAN)
16226                     fputs (" R4KEOP_CLEAN", stdout);
16227                   break;
16228                 case ODK_HWOR:
16229                   fputs (" HWOR      ", stdout);
16230                   if (option->info & OHWA0_R4KEOP_CHECKED)
16231                     fputs (" R4KEOP_CHECKED", stdout);
16232                   if (option->info & OHWA0_R4KEOP_CLEAN)
16233                     fputs (" R4KEOP_CLEAN", stdout);
16234                   break;
16235                 case ODK_GP_GROUP:
16236                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16237                           option->info & OGP_GROUP,
16238                           (option->info & OGP_SELF) >> 16);
16239                   break;
16240                 case ODK_IDENT:
16241                   printf (" IDENT     %#06lx  self-contained %#06lx",
16242                           option->info & OGP_GROUP,
16243                           (option->info & OGP_SELF) >> 16);
16244                   break;
16245                 default:
16246                   /* This shouldn't happen.  */
16247                   printf (" %3d ???     %d %lx",
16248                           option->kind, option->section, option->info);
16249                   break;
16250                 }
16251
16252               len = sizeof (* eopt);
16253               while (len < option->size)
16254                 {
16255                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16256
16257                   if (ISPRINT (datum))
16258                     printf ("%c", datum);
16259                   else
16260                     printf ("\\%03o", datum);
16261                   len ++;
16262                 }
16263               fputs ("\n", stdout);
16264
16265               offset += option->size;
16266               ++option;
16267             }
16268
16269           free (eopt);
16270         }
16271       else
16272         res = FALSE;
16273     }
16274
16275   if (conflicts_offset != 0 && conflictsno != 0)
16276     {
16277       Elf32_Conflict * iconf;
16278       size_t cnt;
16279
16280       if (dynamic_symbols == NULL)
16281         {
16282           error (_("conflict list found without a dynamic symbol table\n"));
16283           return FALSE;
16284         }
16285
16286       /* PR 21345 - print a slightly more helpful error message
16287          if we are sure that the cmalloc will fail.  */
16288       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16289         {
16290           error (_("Overlarge number of conflicts detected: %lx\n"),
16291                  (long) conflictsno);
16292           return FALSE;
16293         }
16294
16295       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16296       if (iconf == NULL)
16297         {
16298           error (_("Out of memory allocating space for dynamic conflicts\n"));
16299           return FALSE;
16300         }
16301
16302       if (is_32bit_elf)
16303         {
16304           Elf32_External_Conflict * econf32;
16305
16306           econf32 = (Elf32_External_Conflict *)
16307               get_data (NULL, filedata, conflicts_offset, conflictsno,
16308                         sizeof (* econf32), _("conflict"));
16309           if (!econf32)
16310             return FALSE;
16311
16312           for (cnt = 0; cnt < conflictsno; ++cnt)
16313             iconf[cnt] = BYTE_GET (econf32[cnt]);
16314
16315           free (econf32);
16316         }
16317       else
16318         {
16319           Elf64_External_Conflict * econf64;
16320
16321           econf64 = (Elf64_External_Conflict *)
16322               get_data (NULL, filedata, conflicts_offset, conflictsno,
16323                         sizeof (* econf64), _("conflict"));
16324           if (!econf64)
16325             return FALSE;
16326
16327           for (cnt = 0; cnt < conflictsno; ++cnt)
16328             iconf[cnt] = BYTE_GET (econf64[cnt]);
16329
16330           free (econf64);
16331         }
16332
16333       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16334                         "\nSection '.conflict' contains %lu entries:\n",
16335                         (unsigned long) conflictsno),
16336               (unsigned long) conflictsno);
16337       puts (_("  Num:    Index       Value  Name"));
16338
16339       for (cnt = 0; cnt < conflictsno; ++cnt)
16340         {
16341           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16342
16343           if (iconf[cnt] >= num_dynamic_syms)
16344             printf (_("<corrupt symbol index>"));
16345           else
16346             {
16347               Elf_Internal_Sym * psym;
16348
16349               psym = & dynamic_symbols[iconf[cnt]];
16350               print_vma (psym->st_value, FULL_HEX);
16351               putchar (' ');
16352               if (VALID_DYNAMIC_NAME (psym->st_name))
16353                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16354               else
16355                 printf (_("<corrupt: %14ld>"), psym->st_name);
16356             }
16357           putchar ('\n');
16358         }
16359
16360       free (iconf);
16361     }
16362
16363   if (pltgot != 0 && local_gotno != 0)
16364     {
16365       bfd_vma ent, local_end, global_end;
16366       size_t i, offset;
16367       unsigned char * data;
16368       unsigned char * data_end;
16369       int addr_size;
16370
16371       ent = pltgot;
16372       addr_size = (is_32bit_elf ? 4 : 8);
16373       local_end = pltgot + local_gotno * addr_size;
16374
16375       /* PR binutils/17533 file: 012-111227-0.004  */
16376       if (symtabno < gotsym)
16377         {
16378           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16379                  (unsigned long) gotsym, (unsigned long) symtabno);
16380           return FALSE;
16381         }
16382
16383       global_end = local_end + (symtabno - gotsym) * addr_size;
16384       /* PR 17531: file: 54c91a34.  */
16385       if (global_end < local_end)
16386         {
16387           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16388           return FALSE;
16389         }
16390
16391       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16392       data = (unsigned char *) get_data (NULL, filedata, offset,
16393                                          global_end - pltgot, 1,
16394                                          _("Global Offset Table data"));
16395       /* PR 12855: Null data is handled gracefully throughout.  */
16396       data_end = data + (global_end - pltgot);
16397
16398       printf (_("\nPrimary GOT:\n"));
16399       printf (_(" Canonical gp value: "));
16400       print_vma (pltgot + 0x7ff0, LONG_HEX);
16401       printf ("\n\n");
16402
16403       printf (_(" Reserved entries:\n"));
16404       printf (_("  %*s %10s %*s Purpose\n"),
16405               addr_size * 2, _("Address"), _("Access"),
16406               addr_size * 2, _("Initial"));
16407       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16408       printf (_(" Lazy resolver\n"));
16409       if (ent == (bfd_vma) -1)
16410         goto got_print_fail;
16411
16412       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16413          This entry will be used by some runtime loaders, to store the
16414          module pointer.  Otherwise this is an ordinary local entry.
16415          PR 21344: Check for the entry being fully available before
16416          fetching it.  */
16417       if (data
16418           && data + ent - pltgot + addr_size <= data_end
16419           && (byte_get (data + ent - pltgot, addr_size)
16420               >> (addr_size * 8 - 1)) != 0)
16421         {
16422           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16423           printf (_(" Module pointer (GNU extension)\n"));
16424           if (ent == (bfd_vma) -1)
16425             goto got_print_fail;
16426         }
16427       printf ("\n");
16428
16429       if (data != NULL && ent < local_end)
16430         {
16431           printf (_(" Local entries:\n"));
16432           printf ("  %*s %10s %*s\n",
16433                   addr_size * 2, _("Address"), _("Access"),
16434                   addr_size * 2, _("Initial"));
16435           while (ent < local_end)
16436             {
16437               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16438               printf ("\n");
16439               if (ent == (bfd_vma) -1)
16440                 goto got_print_fail;
16441             }
16442           printf ("\n");
16443         }
16444
16445       if (data != NULL && gotsym < symtabno)
16446         {
16447           int sym_width;
16448
16449           printf (_(" Global entries:\n"));
16450           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16451                   addr_size * 2, _("Address"),
16452                   _("Access"),
16453                   addr_size * 2, _("Initial"),
16454                   addr_size * 2, _("Sym.Val."),
16455                   _("Type"),
16456                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16457                   _("Ndx"), _("Name"));
16458
16459           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16460
16461           for (i = gotsym; i < symtabno; i++)
16462             {
16463               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16464               printf (" ");
16465
16466               if (dynamic_symbols == NULL)
16467                 printf (_("<no dynamic symbols>"));
16468               else if (i < num_dynamic_syms)
16469                 {
16470                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16471
16472                   print_vma (psym->st_value, LONG_HEX);
16473                   printf (" %-7s %3s ",
16474                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16475                           get_symbol_index_type (filedata, psym->st_shndx));
16476
16477                   if (VALID_DYNAMIC_NAME (psym->st_name))
16478                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16479                   else
16480                     printf (_("<corrupt: %14ld>"), psym->st_name);
16481                 }
16482               else
16483                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16484                         (unsigned long) i);
16485
16486               printf ("\n");
16487               if (ent == (bfd_vma) -1)
16488                 break;
16489             }
16490           printf ("\n");
16491         }
16492
16493     got_print_fail:
16494       if (data)
16495         free (data);
16496     }
16497
16498   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16499     {
16500       bfd_vma ent, end;
16501       size_t offset, rel_offset;
16502       unsigned long count, i;
16503       unsigned char * data;
16504       int addr_size, sym_width;
16505       Elf_Internal_Rela * rels;
16506
16507       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16508       if (pltrel == DT_RELA)
16509         {
16510           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16511             return FALSE;
16512         }
16513       else
16514         {
16515           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16516             return FALSE;
16517         }
16518
16519       ent = mips_pltgot;
16520       addr_size = (is_32bit_elf ? 4 : 8);
16521       end = mips_pltgot + (2 + count) * addr_size;
16522
16523       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16524       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16525                                          1, _("Procedure Linkage Table data"));
16526       if (data == NULL)
16527         return FALSE;
16528
16529       printf ("\nPLT GOT:\n\n");
16530       printf (_(" Reserved entries:\n"));
16531       printf (_("  %*s %*s Purpose\n"),
16532               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16533       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16534       printf (_(" PLT lazy resolver\n"));
16535       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16536       printf (_(" Module pointer\n"));
16537       printf ("\n");
16538
16539       printf (_(" Entries:\n"));
16540       printf ("  %*s %*s %*s %-7s %3s %s\n",
16541               addr_size * 2, _("Address"),
16542               addr_size * 2, _("Initial"),
16543               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16544       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16545       for (i = 0; i < count; i++)
16546         {
16547           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16548
16549           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16550           printf (" ");
16551
16552           if (idx >= num_dynamic_syms)
16553             printf (_("<corrupt symbol index: %lu>"), idx);
16554           else
16555             {
16556               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16557
16558               print_vma (psym->st_value, LONG_HEX);
16559               printf (" %-7s %3s ",
16560                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16561                       get_symbol_index_type (filedata, psym->st_shndx));
16562               if (VALID_DYNAMIC_NAME (psym->st_name))
16563                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16564               else
16565                 printf (_("<corrupt: %14ld>"), psym->st_name);
16566             }
16567           printf ("\n");
16568         }
16569       printf ("\n");
16570
16571       if (data)
16572         free (data);
16573       free (rels);
16574     }
16575
16576   return res;
16577 }
16578
16579 static bfd_boolean
16580 process_nds32_specific (Filedata * filedata)
16581 {
16582   Elf_Internal_Shdr *sect = NULL;
16583
16584   sect = find_section (filedata, ".nds32_e_flags");
16585   if (sect != NULL)
16586     {
16587       unsigned int *flag;
16588
16589       printf ("\nNDS32 elf flags section:\n");
16590       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16591                        sect->sh_size, _("NDS32 elf flags section"));
16592
16593       if (! flag)
16594         return FALSE;
16595
16596       switch ((*flag) & 0x3)
16597         {
16598         case 0:
16599           printf ("(VEC_SIZE):\tNo entry.\n");
16600           break;
16601         case 1:
16602           printf ("(VEC_SIZE):\t4 bytes\n");
16603           break;
16604         case 2:
16605           printf ("(VEC_SIZE):\t16 bytes\n");
16606           break;
16607         case 3:
16608           printf ("(VEC_SIZE):\treserved\n");
16609           break;
16610         }
16611     }
16612
16613   return TRUE;
16614 }
16615
16616 static bfd_boolean
16617 process_gnu_liblist (Filedata * filedata)
16618 {
16619   Elf_Internal_Shdr * section;
16620   Elf_Internal_Shdr * string_sec;
16621   Elf32_External_Lib * elib;
16622   char * strtab;
16623   size_t strtab_size;
16624   size_t cnt;
16625   unsigned long num_liblist;
16626   unsigned i;
16627   bfd_boolean res = TRUE;
16628
16629   if (! do_arch)
16630     return TRUE;
16631
16632   for (i = 0, section = filedata->section_headers;
16633        i < filedata->file_header.e_shnum;
16634        i++, section++)
16635     {
16636       switch (section->sh_type)
16637         {
16638         case SHT_GNU_LIBLIST:
16639           if (section->sh_link >= filedata->file_header.e_shnum)
16640             break;
16641
16642           elib = (Elf32_External_Lib *)
16643               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16644                         _("liblist section data"));
16645
16646           if (elib == NULL)
16647             {
16648               res = FALSE;
16649               break;
16650             }
16651
16652           string_sec = filedata->section_headers + section->sh_link;
16653           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16654                                       string_sec->sh_size,
16655                                       _("liblist string table"));
16656           if (strtab == NULL
16657               || section->sh_entsize != sizeof (Elf32_External_Lib))
16658             {
16659               free (elib);
16660               free (strtab);
16661               res = FALSE;
16662               break;
16663             }
16664           strtab_size = string_sec->sh_size;
16665
16666           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16667           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16668                             "\nLibrary list section '%s' contains %lu entries:\n",
16669                             num_liblist),
16670                   printable_section_name (filedata, section),
16671                   num_liblist);
16672
16673           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16674
16675           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16676                ++cnt)
16677             {
16678               Elf32_Lib liblist;
16679               time_t atime;
16680               char timebuf[128];
16681               struct tm * tmp;
16682
16683               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16684               atime = BYTE_GET (elib[cnt].l_time_stamp);
16685               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16686               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16687               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16688
16689               tmp = gmtime (&atime);
16690               snprintf (timebuf, sizeof (timebuf),
16691                         "%04u-%02u-%02uT%02u:%02u:%02u",
16692                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16693                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16694
16695               printf ("%3lu: ", (unsigned long) cnt);
16696               if (do_wide)
16697                 printf ("%-20s", liblist.l_name < strtab_size
16698                         ? strtab + liblist.l_name : _("<corrupt>"));
16699               else
16700                 printf ("%-20.20s", liblist.l_name < strtab_size
16701                         ? strtab + liblist.l_name : _("<corrupt>"));
16702               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16703                       liblist.l_version, liblist.l_flags);
16704             }
16705
16706           free (elib);
16707           free (strtab);
16708         }
16709     }
16710
16711   return res;
16712 }
16713
16714 static const char *
16715 get_note_type (Filedata * filedata, unsigned e_type)
16716 {
16717   static char buff[64];
16718
16719   if (filedata->file_header.e_type == ET_CORE)
16720     switch (e_type)
16721       {
16722       case NT_AUXV:
16723         return _("NT_AUXV (auxiliary vector)");
16724       case NT_PRSTATUS:
16725         return _("NT_PRSTATUS (prstatus structure)");
16726       case NT_FPREGSET:
16727         return _("NT_FPREGSET (floating point registers)");
16728       case NT_PRPSINFO:
16729         return _("NT_PRPSINFO (prpsinfo structure)");
16730       case NT_TASKSTRUCT:
16731         return _("NT_TASKSTRUCT (task structure)");
16732       case NT_PRXFPREG:
16733         return _("NT_PRXFPREG (user_xfpregs structure)");
16734       case NT_PPC_VMX:
16735         return _("NT_PPC_VMX (ppc Altivec registers)");
16736       case NT_PPC_VSX:
16737         return _("NT_PPC_VSX (ppc VSX registers)");
16738       case NT_PPC_TAR:
16739         return _("NT_PPC_TAR (ppc TAR register)");
16740       case NT_PPC_PPR:
16741         return _("NT_PPC_PPR (ppc PPR register)");
16742       case NT_PPC_DSCR:
16743         return _("NT_PPC_DSCR (ppc DSCR register)");
16744       case NT_PPC_EBB:
16745         return _("NT_PPC_EBB (ppc EBB registers)");
16746       case NT_PPC_PMU:
16747         return _("NT_PPC_PMU (ppc PMU registers)");
16748       case NT_PPC_TM_CGPR:
16749         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16750       case NT_PPC_TM_CFPR:
16751         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16752       case NT_PPC_TM_CVMX:
16753         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16754       case NT_PPC_TM_CVSX:
16755         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16756       case NT_PPC_TM_SPR:
16757         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16758       case NT_PPC_TM_CTAR:
16759         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16760       case NT_PPC_TM_CPPR:
16761         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16762       case NT_PPC_TM_CDSCR:
16763         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16764       case NT_386_TLS:
16765         return _("NT_386_TLS (x86 TLS information)");
16766       case NT_386_IOPERM:
16767         return _("NT_386_IOPERM (x86 I/O permissions)");
16768       case NT_X86_XSTATE:
16769         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16770       case NT_S390_HIGH_GPRS:
16771         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16772       case NT_S390_TIMER:
16773         return _("NT_S390_TIMER (s390 timer register)");
16774       case NT_S390_TODCMP:
16775         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16776       case NT_S390_TODPREG:
16777         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16778       case NT_S390_CTRS:
16779         return _("NT_S390_CTRS (s390 control registers)");
16780       case NT_S390_PREFIX:
16781         return _("NT_S390_PREFIX (s390 prefix register)");
16782       case NT_S390_LAST_BREAK:
16783         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16784       case NT_S390_SYSTEM_CALL:
16785         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16786       case NT_S390_TDB:
16787         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16788       case NT_S390_VXRS_LOW:
16789         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16790       case NT_S390_VXRS_HIGH:
16791         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16792       case NT_S390_GS_CB:
16793         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16794       case NT_S390_GS_BC:
16795         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16796       case NT_ARM_VFP:
16797         return _("NT_ARM_VFP (arm VFP registers)");
16798       case NT_ARM_TLS:
16799         return _("NT_ARM_TLS (AArch TLS registers)");
16800       case NT_ARM_HW_BREAK:
16801         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16802       case NT_ARM_HW_WATCH:
16803         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16804       case NT_PSTATUS:
16805         return _("NT_PSTATUS (pstatus structure)");
16806       case NT_FPREGS:
16807         return _("NT_FPREGS (floating point registers)");
16808       case NT_PSINFO:
16809         return _("NT_PSINFO (psinfo structure)");
16810       case NT_LWPSTATUS:
16811         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16812       case NT_LWPSINFO:
16813         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16814       case NT_WIN32PSTATUS:
16815         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16816       case NT_SIGINFO:
16817         return _("NT_SIGINFO (siginfo_t data)");
16818       case NT_FILE:
16819         return _("NT_FILE (mapped files)");
16820       default:
16821         break;
16822       }
16823   else
16824     switch (e_type)
16825       {
16826       case NT_VERSION:
16827         return _("NT_VERSION (version)");
16828       case NT_ARCH:
16829         return _("NT_ARCH (architecture)");
16830       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16831         return _("OPEN");
16832       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16833         return _("func");
16834       default:
16835         break;
16836       }
16837
16838   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16839   return buff;
16840 }
16841
16842 static bfd_boolean
16843 print_core_note (Elf_Internal_Note *pnote)
16844 {
16845   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16846   bfd_vma count, page_size;
16847   unsigned char *descdata, *filenames, *descend;
16848
16849   if (pnote->type != NT_FILE)
16850     {
16851       if (do_wide)
16852         printf ("\n");
16853       return TRUE;
16854     }
16855
16856 #ifndef BFD64
16857   if (!is_32bit_elf)
16858     {
16859       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16860       /* Still "successful".  */
16861       return TRUE;
16862     }
16863 #endif
16864
16865   if (pnote->descsz < 2 * addr_size)
16866     {
16867       error (_("    Malformed note - too short for header\n"));
16868       return FALSE;
16869     }
16870
16871   descdata = (unsigned char *) pnote->descdata;
16872   descend = descdata + pnote->descsz;
16873
16874   if (descdata[pnote->descsz - 1] != '\0')
16875     {
16876       error (_("    Malformed note - does not end with \\0\n"));
16877       return FALSE;
16878     }
16879
16880   count = byte_get (descdata, addr_size);
16881   descdata += addr_size;
16882
16883   page_size = byte_get (descdata, addr_size);
16884   descdata += addr_size;
16885
16886   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16887       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16888     {
16889       error (_("    Malformed note - too short for supplied file count\n"));
16890       return FALSE;
16891     }
16892
16893   printf (_("    Page size: "));
16894   print_vma (page_size, DEC);
16895   printf ("\n");
16896
16897   printf (_("    %*s%*s%*s\n"),
16898           (int) (2 + 2 * addr_size), _("Start"),
16899           (int) (4 + 2 * addr_size), _("End"),
16900           (int) (4 + 2 * addr_size), _("Page Offset"));
16901   filenames = descdata + count * 3 * addr_size;
16902   while (count-- > 0)
16903     {
16904       bfd_vma start, end, file_ofs;
16905
16906       if (filenames == descend)
16907         {
16908           error (_("    Malformed note - filenames end too early\n"));
16909           return FALSE;
16910         }
16911
16912       start = byte_get (descdata, addr_size);
16913       descdata += addr_size;
16914       end = byte_get (descdata, addr_size);
16915       descdata += addr_size;
16916       file_ofs = byte_get (descdata, addr_size);
16917       descdata += addr_size;
16918
16919       printf ("    ");
16920       print_vma (start, FULL_HEX);
16921       printf ("  ");
16922       print_vma (end, FULL_HEX);
16923       printf ("  ");
16924       print_vma (file_ofs, FULL_HEX);
16925       printf ("\n        %s\n", filenames);
16926
16927       filenames += 1 + strlen ((char *) filenames);
16928     }
16929
16930   return TRUE;
16931 }
16932
16933 static const char *
16934 get_gnu_elf_note_type (unsigned e_type)
16935 {
16936   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16937   switch (e_type)
16938     {
16939     case NT_GNU_ABI_TAG:
16940       return _("NT_GNU_ABI_TAG (ABI version tag)");
16941     case NT_GNU_HWCAP:
16942       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16943     case NT_GNU_BUILD_ID:
16944       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16945     case NT_GNU_GOLD_VERSION:
16946       return _("NT_GNU_GOLD_VERSION (gold version)");
16947     case NT_GNU_PROPERTY_TYPE_0:
16948       return _("NT_GNU_PROPERTY_TYPE_0");
16949     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16950       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16951     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16952       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16953     default:
16954       {
16955         static char buff[64];
16956
16957         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16958         return buff;
16959       }
16960     }
16961 }
16962
16963 static void
16964 decode_x86_compat_isa (unsigned int bitmask)
16965 {
16966   while (bitmask)
16967     {
16968       unsigned int bit = bitmask & (- bitmask);
16969
16970       bitmask &= ~ bit;
16971       switch (bit)
16972         {
16973         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16974           printf ("i486");
16975           break;
16976         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16977           printf ("586");
16978           break;
16979         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16980           printf ("686");
16981           break;
16982         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16983           printf ("SSE");
16984           break;
16985         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16986           printf ("SSE2");
16987           break;
16988         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16989           printf ("SSE3");
16990           break;
16991         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16992           printf ("SSSE3");
16993           break;
16994         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16995           printf ("SSE4_1");
16996           break;
16997         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
16998           printf ("SSE4_2");
16999           break;
17000         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17001           printf ("AVX");
17002           break;
17003         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17004           printf ("AVX2");
17005           break;
17006         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17007           printf ("AVX512F");
17008           break;
17009         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17010           printf ("AVX512CD");
17011           break;
17012         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17013           printf ("AVX512ER");
17014           break;
17015         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17016           printf ("AVX512PF");
17017           break;
17018         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17019           printf ("AVX512VL");
17020           break;
17021         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17022           printf ("AVX512DQ");
17023           break;
17024         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17025           printf ("AVX512BW");
17026           break;
17027         default:
17028           printf (_("<unknown: %x>"), bit);
17029           break;
17030         }
17031       if (bitmask)
17032         printf (", ");
17033     }
17034 }
17035
17036 static void
17037 decode_x86_isa (unsigned int bitmask)
17038 {
17039   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17040     {
17041       printf (_("<None>"));
17042       return;
17043     }
17044   else
17045     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17046
17047   while (bitmask)
17048     {
17049       unsigned int bit = bitmask & (- bitmask);
17050
17051       bitmask &= ~ bit;
17052       switch (bit)
17053         {
17054         case GNU_PROPERTY_X86_ISA_1_CMOV:
17055           printf ("CMOV");
17056           break;
17057         case GNU_PROPERTY_X86_ISA_1_SSE:
17058           printf ("SSE");
17059           break;
17060         case GNU_PROPERTY_X86_ISA_1_SSE2:
17061           printf ("SSE2");
17062           break;
17063         case GNU_PROPERTY_X86_ISA_1_SSE3:
17064           printf ("SSE3");
17065           break;
17066         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17067           printf ("SSSE3");
17068           break;
17069         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17070           printf ("SSE4_1");
17071           break;
17072         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17073           printf ("SSE4_2");
17074           break;
17075         case GNU_PROPERTY_X86_ISA_1_AVX:
17076           printf ("AVX");
17077           break;
17078         case GNU_PROPERTY_X86_ISA_1_AVX2:
17079           printf ("AVX2");
17080           break;
17081         case GNU_PROPERTY_X86_ISA_1_FMA:
17082           printf ("FMA");
17083           break;
17084         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17085           printf ("AVX512F");
17086           break;
17087         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17088           printf ("AVX512CD");
17089           break;
17090         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17091           printf ("AVX512ER");
17092           break;
17093         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17094           printf ("AVX512PF");
17095           break;
17096         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17097           printf ("AVX512VL");
17098           break;
17099         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17100           printf ("AVX512DQ");
17101           break;
17102         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17103           printf ("AVX512BW");
17104           break;
17105         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17106           printf ("AVX512_4FMAPS");
17107           break;
17108         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17109           printf ("AVX512_4VNNIW");
17110           break;
17111         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17112           printf ("AVX512_BITALG");
17113           break;
17114         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17115           printf ("AVX512_IFMA");
17116           break;
17117         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17118           printf ("AVX512_VBMI");
17119           break;
17120         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17121           printf ("AVX512_VBMI2");
17122           break;
17123         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17124           printf ("AVX512_VNNI");
17125           break;
17126         default:
17127           printf (_("<unknown: %x>"), bit);
17128           break;
17129         }
17130       if (bitmask)
17131         printf (", ");
17132     }
17133 }
17134
17135 static void
17136 decode_x86_feature_1 (unsigned int bitmask)
17137 {
17138   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17139     {
17140       printf (_("<None>"));
17141       return;
17142     }
17143   else
17144     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17145
17146   while (bitmask)
17147     {
17148       unsigned int bit = bitmask & (- bitmask);
17149
17150       bitmask &= ~ bit;
17151       switch (bit)
17152         {
17153         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17154           printf ("IBT");
17155           break;
17156         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17157           printf ("SHSTK");
17158           break;
17159         default:
17160           printf (_("<unknown: %x>"), bit);
17161           break;
17162         }
17163       if (bitmask)
17164         printf (", ");
17165     }
17166 }
17167
17168 static void
17169 decode_x86_feature_2 (unsigned int bitmask)
17170 {
17171   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17172     {
17173       printf (_("<None>"));
17174       return;
17175     }
17176   else
17177     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17178
17179   while (bitmask)
17180     {
17181       unsigned int bit = bitmask & (- bitmask);
17182
17183       bitmask &= ~ bit;
17184       switch (bit)
17185         {
17186         case GNU_PROPERTY_X86_FEATURE_2_X86:
17187           printf ("x86");
17188           break;
17189         case GNU_PROPERTY_X86_FEATURE_2_X87:
17190           printf ("x87");
17191           break;
17192         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17193           printf ("MMX");
17194           break;
17195         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17196           printf ("XMM");
17197           break;
17198         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17199           printf ("YMM");
17200           break;
17201         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17202           printf ("ZMM");
17203           break;
17204         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17205           printf ("FXSR");
17206           break;
17207         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17208           printf ("XSAVE");
17209           break;
17210         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17211           printf ("XSAVEOPT");
17212           break;
17213         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17214           printf ("XSAVEC");
17215           break;
17216         default:
17217           printf (_("<unknown: %x>"), bit);
17218           break;
17219         }
17220       if (bitmask)
17221         printf (", ");
17222     }
17223 }
17224
17225 static void
17226 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17227 {
17228   unsigned char * ptr = (unsigned char *) pnote->descdata;
17229   unsigned char * ptr_end = ptr + pnote->descsz;
17230   unsigned int    size = is_32bit_elf ? 4 : 8;
17231
17232   printf (_("      Properties: "));
17233
17234   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17235     {
17236       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17237       return;
17238     }
17239
17240   while (ptr < ptr_end)
17241     {
17242       unsigned int j;
17243       unsigned int type;
17244       unsigned int datasz;
17245
17246       if ((size_t) (ptr_end - ptr) < 8)
17247         {
17248           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17249           break;
17250         }
17251
17252       type = byte_get (ptr, 4);
17253       datasz = byte_get (ptr + 4, 4);
17254
17255       ptr += 8;
17256
17257       if (datasz > (size_t) (ptr_end - ptr))
17258         {
17259           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17260                   type, datasz);
17261           break;
17262         }
17263
17264       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17265         {
17266           if (filedata->file_header.e_machine == EM_X86_64
17267               || filedata->file_header.e_machine == EM_IAMCU
17268               || filedata->file_header.e_machine == EM_386)
17269             {
17270               unsigned int bitmask;
17271
17272               if (datasz == 4)
17273                 {
17274                   bitmask = byte_get (ptr, 4);
17275                   if ((filedata->file_header.e_type == ET_EXEC
17276                        || filedata->file_header.e_type == ET_DYN)
17277                       && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17278                     printf ("Invalid ");
17279                 }
17280               else
17281                 bitmask = 0;
17282
17283               switch (type)
17284                 {
17285                 case GNU_PROPERTY_X86_ISA_1_USED:
17286                   if (datasz != 4)
17287                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17288                             datasz);
17289                   else
17290                     {
17291                       printf ("x86 ISA used: ");
17292                       decode_x86_isa (bitmask);
17293                     }
17294                   goto next;
17295
17296                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17297                   if (datasz != 4)
17298                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17299                             datasz);
17300                   else
17301                     {
17302                       printf ("x86 ISA needed: ");
17303                       decode_x86_isa (bitmask);
17304                     }
17305                   goto next;
17306
17307                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17308                   if (datasz != 4)
17309                     printf (_("x86 feature: <corrupt length: %#x> "),
17310                             datasz);
17311                   else
17312                     {
17313                       printf ("x86 feature: ");
17314                       decode_x86_feature_1 (bitmask);
17315                     }
17316                   goto next;
17317
17318                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17319                   if (datasz != 4)
17320                     printf (_("x86 feature used: <corrupt length: %#x> "),
17321                             datasz);
17322                   else
17323                     {
17324                       printf ("x86 feature used: ");
17325                       decode_x86_feature_2 (bitmask);
17326                     }
17327                   goto next;
17328
17329                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17330                   if (datasz != 4)
17331                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17332                   else
17333                     {
17334                       printf ("x86 feature needed: ");
17335                       decode_x86_feature_2 (bitmask);
17336                     }
17337                   goto next;
17338
17339                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17340                   if (datasz != 4)
17341                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17342                             datasz);
17343                   else
17344                     {
17345                       printf ("x86 ISA used: ");
17346                       decode_x86_compat_isa (bitmask);
17347                     }
17348                   goto next;
17349
17350                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17351                   if (datasz != 4)
17352                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17353                             datasz);
17354                   else
17355                     {
17356                       printf ("x86 ISA needed: ");
17357                       decode_x86_compat_isa (bitmask);
17358                     }
17359                   goto next;
17360
17361                 default:
17362                   break;
17363                 }
17364             }
17365         }
17366       else
17367         {
17368           switch (type)
17369             {
17370             case GNU_PROPERTY_STACK_SIZE:
17371               printf (_("stack size: "));
17372               if (datasz != size)
17373                 printf (_("<corrupt length: %#x> "), datasz);
17374               else
17375                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17376               goto next;
17377
17378             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17379               printf ("no copy on protected ");
17380               if (datasz)
17381                 printf (_("<corrupt length: %#x> "), datasz);
17382               goto next;
17383
17384             default:
17385               break;
17386             }
17387         }
17388
17389       if (type < GNU_PROPERTY_LOPROC)
17390         printf (_("<unknown type %#x data: "), type);
17391       else if (type < GNU_PROPERTY_LOUSER)
17392         printf (_("<procesor-specific type %#x data: "), type);
17393       else
17394         printf (_("<application-specific type %#x data: "), type);
17395       for (j = 0; j < datasz; ++j)
17396         printf ("%02x ", ptr[j] & 0xff);
17397       printf (">");
17398
17399 next:
17400       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17401       if (ptr == ptr_end)
17402         break;
17403
17404       if (do_wide)
17405         printf (", ");
17406       else
17407         printf ("\n\t");
17408     }
17409
17410   printf ("\n");
17411 }
17412
17413 static bfd_boolean
17414 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17415 {
17416   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17417   switch (pnote->type)
17418     {
17419     case NT_GNU_BUILD_ID:
17420       {
17421         unsigned long i;
17422
17423         printf (_("    Build ID: "));
17424         for (i = 0; i < pnote->descsz; ++i)
17425           printf ("%02x", pnote->descdata[i] & 0xff);
17426         printf ("\n");
17427       }
17428       break;
17429
17430     case NT_GNU_ABI_TAG:
17431       {
17432         unsigned long os, major, minor, subminor;
17433         const char *osname;
17434
17435         /* PR 17531: file: 030-599401-0.004.  */
17436         if (pnote->descsz < 16)
17437           {
17438             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17439             break;
17440           }
17441
17442         os = byte_get ((unsigned char *) pnote->descdata, 4);
17443         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17444         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17445         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17446
17447         switch (os)
17448           {
17449           case GNU_ABI_TAG_LINUX:
17450             osname = "Linux";
17451             break;
17452           case GNU_ABI_TAG_HURD:
17453             osname = "Hurd";
17454             break;
17455           case GNU_ABI_TAG_SOLARIS:
17456             osname = "Solaris";
17457             break;
17458           case GNU_ABI_TAG_FREEBSD:
17459             osname = "FreeBSD";
17460             break;
17461           case GNU_ABI_TAG_NETBSD:
17462             osname = "NetBSD";
17463             break;
17464           case GNU_ABI_TAG_SYLLABLE:
17465             osname = "Syllable";
17466             break;
17467           case GNU_ABI_TAG_NACL:
17468             osname = "NaCl";
17469             break;
17470           default:
17471             osname = "Unknown";
17472             break;
17473           }
17474
17475         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17476                 major, minor, subminor);
17477       }
17478       break;
17479
17480     case NT_GNU_GOLD_VERSION:
17481       {
17482         unsigned long i;
17483
17484         printf (_("    Version: "));
17485         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17486           printf ("%c", pnote->descdata[i]);
17487         printf ("\n");
17488       }
17489       break;
17490
17491     case NT_GNU_HWCAP:
17492       {
17493         unsigned long num_entries, mask;
17494
17495         /* Hardware capabilities information.  Word 0 is the number of entries.
17496            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17497            is a series of entries, where each entry is a single byte followed
17498            by a nul terminated string.  The byte gives the bit number to test
17499            if enabled in the bitmask.  */
17500         printf (_("      Hardware Capabilities: "));
17501         if (pnote->descsz < 8)
17502           {
17503             error (_("<corrupt GNU_HWCAP>\n"));
17504             return FALSE;
17505           }
17506         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17507         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17508         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17509         /* FIXME: Add code to display the entries... */
17510       }
17511       break;
17512
17513     case NT_GNU_PROPERTY_TYPE_0:
17514       print_gnu_property_note (filedata, pnote);
17515       break;
17516
17517     default:
17518       /* Handle unrecognised types.  An error message should have already been
17519          created by get_gnu_elf_note_type(), so all that we need to do is to
17520          display the data.  */
17521       {
17522         unsigned long i;
17523
17524         printf (_("    Description data: "));
17525         for (i = 0; i < pnote->descsz; ++i)
17526           printf ("%02x ", pnote->descdata[i] & 0xff);
17527         printf ("\n");
17528       }
17529       break;
17530     }
17531
17532   return TRUE;
17533 }
17534
17535 static const char *
17536 get_v850_elf_note_type (enum v850_notes n_type)
17537 {
17538   static char buff[64];
17539
17540   switch (n_type)
17541     {
17542     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17543     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17544     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17545     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17546     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17547     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17548     default:
17549       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17550       return buff;
17551     }
17552 }
17553
17554 static bfd_boolean
17555 print_v850_note (Elf_Internal_Note * pnote)
17556 {
17557   unsigned int val;
17558
17559   if (pnote->descsz != 4)
17560     return FALSE;
17561
17562   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17563
17564   if (val == 0)
17565     {
17566       printf (_("not set\n"));
17567       return TRUE;
17568     }
17569
17570   switch (pnote->type)
17571     {
17572     case V850_NOTE_ALIGNMENT:
17573       switch (val)
17574         {
17575         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17576         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17577         }
17578       break;
17579
17580     case V850_NOTE_DATA_SIZE:
17581       switch (val)
17582         {
17583         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17584         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17585         }
17586       break;
17587
17588     case V850_NOTE_FPU_INFO:
17589       switch (val)
17590         {
17591         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17592         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17593         }
17594       break;
17595
17596     case V850_NOTE_MMU_INFO:
17597     case V850_NOTE_CACHE_INFO:
17598     case V850_NOTE_SIMD_INFO:
17599       if (val == EF_RH850_SIMD)
17600         {
17601           printf (_("yes\n"));
17602           return TRUE;
17603         }
17604       break;
17605
17606     default:
17607       /* An 'unknown note type' message will already have been displayed.  */
17608       break;
17609     }
17610
17611   printf (_("unknown value: %x\n"), val);
17612   return FALSE;
17613 }
17614
17615 static bfd_boolean
17616 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17617 {
17618   unsigned int version;
17619
17620   switch (pnote->type)
17621     {
17622     case NT_NETBSD_IDENT:
17623       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17624       if ((version / 10000) % 100)
17625         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17626                 version, version / 100000000, (version / 1000000) % 100,
17627                 (version / 10000) % 100 > 26 ? "Z" : "",
17628                 'A' + (version / 10000) % 26);
17629       else
17630         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17631                 version, version / 100000000, (version / 1000000) % 100,
17632                 (version / 100) % 100);
17633       return TRUE;
17634
17635     case NT_NETBSD_MARCH:
17636       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17637               pnote->descdata);
17638       return TRUE;
17639
17640     default:
17641       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17642               pnote->type);
17643       return FALSE;
17644     }
17645 }
17646
17647 static const char *
17648 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17649 {
17650   switch (e_type)
17651     {
17652     case NT_FREEBSD_THRMISC:
17653       return _("NT_THRMISC (thrmisc structure)");
17654     case NT_FREEBSD_PROCSTAT_PROC:
17655       return _("NT_PROCSTAT_PROC (proc data)");
17656     case NT_FREEBSD_PROCSTAT_FILES:
17657       return _("NT_PROCSTAT_FILES (files data)");
17658     case NT_FREEBSD_PROCSTAT_VMMAP:
17659       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17660     case NT_FREEBSD_PROCSTAT_GROUPS:
17661       return _("NT_PROCSTAT_GROUPS (groups data)");
17662     case NT_FREEBSD_PROCSTAT_UMASK:
17663       return _("NT_PROCSTAT_UMASK (umask data)");
17664     case NT_FREEBSD_PROCSTAT_RLIMIT:
17665       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17666     case NT_FREEBSD_PROCSTAT_OSREL:
17667       return _("NT_PROCSTAT_OSREL (osreldate data)");
17668     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17669       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17670     case NT_FREEBSD_PROCSTAT_AUXV:
17671       return _("NT_PROCSTAT_AUXV (auxv data)");
17672     case NT_FREEBSD_PTLWPINFO:
17673       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17674     }
17675   return get_note_type (filedata, e_type);
17676 }
17677
17678 static const char *
17679 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17680 {
17681   static char buff[64];
17682
17683   if (e_type == NT_NETBSDCORE_PROCINFO)
17684     return _("NetBSD procinfo structure");
17685
17686   /* As of Jan 2002 there are no other machine-independent notes
17687      defined for NetBSD core files.  If the note type is less
17688      than the start of the machine-dependent note types, we don't
17689      understand it.  */
17690
17691   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17692     {
17693       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17694       return buff;
17695     }
17696
17697   switch (filedata->file_header.e_machine)
17698     {
17699     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17700        and PT_GETFPREGS == mach+2.  */
17701
17702     case EM_OLD_ALPHA:
17703     case EM_ALPHA:
17704     case EM_SPARC:
17705     case EM_SPARC32PLUS:
17706     case EM_SPARCV9:
17707       switch (e_type)
17708         {
17709         case NT_NETBSDCORE_FIRSTMACH + 0:
17710           return _("PT_GETREGS (reg structure)");
17711         case NT_NETBSDCORE_FIRSTMACH + 2:
17712           return _("PT_GETFPREGS (fpreg structure)");
17713         default:
17714           break;
17715         }
17716       break;
17717
17718     /* On all other arch's, PT_GETREGS == mach+1 and
17719        PT_GETFPREGS == mach+3.  */
17720     default:
17721       switch (e_type)
17722         {
17723         case NT_NETBSDCORE_FIRSTMACH + 1:
17724           return _("PT_GETREGS (reg structure)");
17725         case NT_NETBSDCORE_FIRSTMACH + 3:
17726           return _("PT_GETFPREGS (fpreg structure)");
17727         default:
17728           break;
17729         }
17730     }
17731
17732   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17733             e_type - NT_NETBSDCORE_FIRSTMACH);
17734   return buff;
17735 }
17736
17737 static const char *
17738 get_stapsdt_note_type (unsigned e_type)
17739 {
17740   static char buff[64];
17741
17742   switch (e_type)
17743     {
17744     case NT_STAPSDT:
17745       return _("NT_STAPSDT (SystemTap probe descriptors)");
17746
17747     default:
17748       break;
17749     }
17750
17751   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17752   return buff;
17753 }
17754
17755 static bfd_boolean
17756 print_stapsdt_note (Elf_Internal_Note *pnote)
17757 {
17758   int addr_size = is_32bit_elf ? 4 : 8;
17759   char *data = pnote->descdata;
17760   char *data_end = pnote->descdata + pnote->descsz;
17761   bfd_vma pc, base_addr, semaphore;
17762   char *provider, *probe, *arg_fmt;
17763
17764   pc = byte_get ((unsigned char *) data, addr_size);
17765   data += addr_size;
17766   base_addr = byte_get ((unsigned char *) data, addr_size);
17767   data += addr_size;
17768   semaphore = byte_get ((unsigned char *) data, addr_size);
17769   data += addr_size;
17770
17771   provider = data;
17772   data += strlen (data) + 1;
17773   probe = data;
17774   data += strlen (data) + 1;
17775   arg_fmt = data;
17776   data += strlen (data) + 1;
17777
17778   printf (_("    Provider: %s\n"), provider);
17779   printf (_("    Name: %s\n"), probe);
17780   printf (_("    Location: "));
17781   print_vma (pc, FULL_HEX);
17782   printf (_(", Base: "));
17783   print_vma (base_addr, FULL_HEX);
17784   printf (_(", Semaphore: "));
17785   print_vma (semaphore, FULL_HEX);
17786   printf ("\n");
17787   printf (_("    Arguments: %s\n"), arg_fmt);
17788
17789   return data == data_end;
17790 }
17791
17792 static const char *
17793 get_ia64_vms_note_type (unsigned e_type)
17794 {
17795   static char buff[64];
17796
17797   switch (e_type)
17798     {
17799     case NT_VMS_MHD:
17800       return _("NT_VMS_MHD (module header)");
17801     case NT_VMS_LNM:
17802       return _("NT_VMS_LNM (language name)");
17803     case NT_VMS_SRC:
17804       return _("NT_VMS_SRC (source files)");
17805     case NT_VMS_TITLE:
17806       return "NT_VMS_TITLE";
17807     case NT_VMS_EIDC:
17808       return _("NT_VMS_EIDC (consistency check)");
17809     case NT_VMS_FPMODE:
17810       return _("NT_VMS_FPMODE (FP mode)");
17811     case NT_VMS_LINKTIME:
17812       return "NT_VMS_LINKTIME";
17813     case NT_VMS_IMGNAM:
17814       return _("NT_VMS_IMGNAM (image name)");
17815     case NT_VMS_IMGID:
17816       return _("NT_VMS_IMGID (image id)");
17817     case NT_VMS_LINKID:
17818       return _("NT_VMS_LINKID (link id)");
17819     case NT_VMS_IMGBID:
17820       return _("NT_VMS_IMGBID (build id)");
17821     case NT_VMS_GSTNAM:
17822       return _("NT_VMS_GSTNAM (sym table name)");
17823     case NT_VMS_ORIG_DYN:
17824       return "NT_VMS_ORIG_DYN";
17825     case NT_VMS_PATCHTIME:
17826       return "NT_VMS_PATCHTIME";
17827     default:
17828       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17829       return buff;
17830     }
17831 }
17832
17833 static bfd_boolean
17834 print_ia64_vms_note (Elf_Internal_Note * pnote)
17835 {
17836   switch (pnote->type)
17837     {
17838     case NT_VMS_MHD:
17839       if (pnote->descsz > 36)
17840         {
17841           size_t l = strlen (pnote->descdata + 34);
17842           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17843           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17844           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17845           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17846         }
17847       else
17848         printf (_("    Invalid size\n"));
17849       break;
17850     case NT_VMS_LNM:
17851       printf (_("   Language: %s\n"), pnote->descdata);
17852       break;
17853 #ifdef BFD64
17854     case NT_VMS_FPMODE:
17855       printf (_("   Floating Point mode: "));
17856       printf ("0x%016" BFD_VMA_FMT "x\n",
17857               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17858       break;
17859     case NT_VMS_LINKTIME:
17860       printf (_("   Link 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_PATCHTIME:
17866       printf (_("   Patch time: "));
17867       print_vms_time
17868         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17869       printf ("\n");
17870       break;
17871     case NT_VMS_ORIG_DYN:
17872       printf (_("   Major id: %u,  minor id: %u\n"),
17873               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17874               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17875       printf (_("   Last modified  : "));
17876       print_vms_time
17877         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17878       printf (_("\n   Link flags  : "));
17879       printf ("0x%016" BFD_VMA_FMT "x\n",
17880               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17881       printf (_("   Header flags: 0x%08x\n"),
17882               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17883       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17884       break;
17885 #endif
17886     case NT_VMS_IMGNAM:
17887       printf (_("    Image name: %s\n"), pnote->descdata);
17888       break;
17889     case NT_VMS_GSTNAM:
17890       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17891       break;
17892     case NT_VMS_IMGID:
17893       printf (_("    Image id: %s\n"), pnote->descdata);
17894       break;
17895     case NT_VMS_LINKID:
17896       printf (_("    Linker id: %s\n"), pnote->descdata);
17897       break;
17898     default:
17899       return FALSE;
17900     }
17901   return TRUE;
17902 }
17903
17904 /* Find the symbol associated with a build attribute that is attached
17905    to address OFFSET.  If PNAME is non-NULL then store the name of
17906    the symbol (if found) in the provided pointer,  Returns NULL if a
17907    symbol could not be found.  */
17908
17909 static Elf_Internal_Sym *
17910 get_symbol_for_build_attribute (Filedata *       filedata,
17911                                 unsigned long    offset,
17912                                 bfd_boolean      is_open_attr,
17913                                 const char **    pname)
17914 {
17915   static Filedata *         saved_filedata = NULL;
17916   static char *             strtab;
17917   static unsigned long      strtablen;
17918   static Elf_Internal_Sym * symtab;
17919   static unsigned long      nsyms;
17920   Elf_Internal_Sym *        saved_sym = NULL;
17921   Elf_Internal_Sym *        sym;
17922
17923   if (filedata->section_headers != NULL
17924       && (saved_filedata == NULL || filedata != saved_filedata))
17925     {
17926       Elf_Internal_Shdr * symsec;
17927
17928       /* Load the symbol and string sections.  */
17929       for (symsec = filedata->section_headers;
17930            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17931            symsec ++)
17932         {
17933           if (symsec->sh_type == SHT_SYMTAB)
17934             {
17935               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17936
17937               if (symsec->sh_link < filedata->file_header.e_shnum)
17938                 {
17939                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17940
17941                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17942                                               1, strtab_sec->sh_size,
17943                                               _("string table"));
17944                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17945                 }
17946             }
17947         }
17948       saved_filedata = filedata;
17949     }
17950
17951   if (symtab == NULL || strtab == NULL)
17952     return NULL;
17953
17954   /* Find a symbol whose value matches offset.  */
17955   for (sym = symtab; sym < symtab + nsyms; sym ++)
17956     if (sym->st_value == offset)
17957       {
17958         if (sym->st_name >= strtablen)
17959           /* Huh ?  This should not happen.  */
17960           continue;
17961
17962         if (strtab[sym->st_name] == 0)
17963           continue;
17964
17965         /* The AArch64 and ARM architectures define mapping symbols
17966            (eg $d, $x, $t) which we want to ignore.  */
17967         if (strtab[sym->st_name] == '$'
17968             && strtab[sym->st_name + 1] != 0
17969             && strtab[sym->st_name + 2] == 0)
17970           continue;
17971
17972         if (is_open_attr)
17973           {
17974             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17975                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17976                FUNC symbols entirely.  */
17977             switch (ELF_ST_TYPE (sym->st_info))
17978               {
17979               case STT_OBJECT:
17980               case STT_FILE:
17981                 saved_sym = sym;
17982                 if (sym->st_size)
17983                   {
17984                     /* If the symbol has a size associated
17985                        with it then we can stop searching.  */
17986                     sym = symtab + nsyms;
17987                   }
17988                 continue;
17989
17990               case STT_FUNC:
17991                 /* Ignore function symbols.  */
17992                 continue;
17993
17994               default:
17995                 break;
17996               }
17997
17998             switch (ELF_ST_BIND (sym->st_info))
17999               {
18000               case STB_GLOBAL:
18001                 if (saved_sym == NULL
18002                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18003                   saved_sym = sym;
18004                 break;
18005
18006               case STB_LOCAL:
18007                 if (saved_sym == NULL)
18008                   saved_sym = sym;
18009                 break;
18010
18011               default:
18012                 break;
18013               }
18014           }
18015         else
18016           {
18017             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18018               continue;
18019
18020             saved_sym = sym;
18021             break;
18022           }
18023       }
18024
18025   if (saved_sym && pname)
18026     * pname = strtab + saved_sym->st_name;
18027
18028   return saved_sym;
18029 }
18030
18031 /* Returns true iff addr1 and addr2 are in the same section.  */
18032
18033 static bfd_boolean
18034 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18035 {
18036   Elf_Internal_Shdr * a1;
18037   Elf_Internal_Shdr * a2;
18038
18039   a1 = find_section_by_address (filedata, addr1);
18040   a2 = find_section_by_address (filedata, addr2);
18041
18042   return a1 == a2 && a1 != NULL;
18043 }
18044
18045 static bfd_boolean
18046 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18047                                        Filedata *           filedata)
18048 {
18049   static unsigned long  global_offset = 0;
18050   static unsigned long  global_end = 0;
18051   static unsigned long  func_offset = 0;
18052   static unsigned long  func_end = 0;
18053
18054   Elf_Internal_Sym *    sym;
18055   const char *          name;
18056   unsigned long         start;
18057   unsigned long         end;
18058   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18059
18060   switch (pnote->descsz)
18061     {
18062     case 0:
18063       /* A zero-length description means that the range of
18064          the previous note of the same type should be used.  */
18065       if (is_open_attr)
18066         {
18067           if (global_end > global_offset)
18068             printf (_("    Applies to region from %#lx to %#lx\n"),
18069                     global_offset, global_end);
18070           else
18071             printf (_("    Applies to region from %#lx\n"), global_offset);
18072         }
18073       else
18074         {
18075           if (func_end > func_offset)
18076             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18077           else
18078             printf (_("    Applies to region from %#lx\n"), func_offset);
18079         }
18080       return TRUE;
18081
18082     case 4:
18083       start = byte_get ((unsigned char *) pnote->descdata, 4);
18084       end = 0;
18085       break;
18086
18087     case 8:
18088       if (is_32bit_elf)
18089         {
18090           /* FIXME: We should check that version 3+ notes are being used here...  */
18091           start = byte_get ((unsigned char *) pnote->descdata, 4);
18092           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18093         }
18094       else
18095         {
18096           start = byte_get ((unsigned char *) pnote->descdata, 8);
18097           end = 0;
18098         }
18099       break;
18100
18101     case 16:
18102       start = byte_get ((unsigned char *) pnote->descdata, 8);
18103       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18104       break;
18105
18106     default:
18107       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18108       printf (_("    <invalid descsz>"));
18109       return FALSE;
18110     }
18111
18112   name = NULL;
18113   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18114   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18115      in order to avoid them being confused with the start address of the
18116      first function in the file...  */
18117   if (sym == NULL && is_open_attr)
18118     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18119                                           & name);
18120
18121   if (end == 0 && sym != NULL && sym->st_size > 0)
18122     end = start + sym->st_size;
18123
18124   if (is_open_attr)
18125     {
18126       /* FIXME: Need to properly allow for section alignment.
18127          16 is just the alignment used on x86_64.  */
18128       if (global_end > 0
18129           && start > BFD_ALIGN (global_end, 16)
18130           /* Build notes are not guaranteed to be organised in order of
18131              increasing address, but we should find the all of the notes
18132              for one section in the same place.  */
18133           && same_section (filedata, start, global_end))
18134         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18135               global_end + 1, start - 1);
18136
18137       printf (_("    Applies to region from %#lx"), start);
18138       global_offset = start;
18139
18140       if (end)
18141         {
18142           printf (_(" to %#lx"), end);
18143           global_end = end;
18144         }
18145     }
18146   else
18147     {
18148       printf (_("    Applies to region from %#lx"), start);
18149       func_offset = start;
18150
18151       if (end)
18152         {
18153           printf (_(" to %#lx"), end);
18154           func_end = end;
18155         }
18156     }
18157
18158   if (sym && name)
18159     printf (_(" (%s)"), name);
18160
18161   printf ("\n");
18162   return TRUE;
18163 }
18164
18165 static bfd_boolean
18166 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18167 {
18168   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18169   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18170   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18171   char         name_type;
18172   char         name_attribute;
18173   const char * expected_types;
18174   const char * name = pnote->namedata;
18175   const char * text;
18176   signed int   left;
18177
18178   if (name == NULL || pnote->namesz < 2)
18179     {
18180       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18181       print_symbol (-20, _("  <corrupt name>"));
18182       return FALSE;
18183     }
18184
18185   if (do_wide)
18186     left = 28;
18187   else
18188     left = 20;
18189
18190   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18191   if (name[0] == 'G' && name[1] == 'A')
18192     {
18193       if (pnote->namesz < 4)
18194         {
18195           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18196           print_symbol (-20, _("  <corrupt name>"));
18197           return FALSE;
18198         }
18199
18200       printf ("GA");
18201       name += 2;
18202       left -= 2;
18203     }
18204
18205   switch ((name_type = * name))
18206     {
18207     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18208     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18209     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18210     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18211       printf ("%c", * name);
18212       left --;
18213       break;
18214     default:
18215       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18216       print_symbol (-20, _("<unknown name type>"));
18217       return FALSE;
18218     }
18219
18220   ++ name;
18221   text = NULL;
18222
18223   switch ((name_attribute = * name))
18224     {
18225     case GNU_BUILD_ATTRIBUTE_VERSION:
18226       text = _("<version>");
18227       expected_types = string_expected;
18228       ++ name;
18229       break;
18230     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18231       text = _("<stack prot>");
18232       expected_types = "!+*";
18233       ++ name;
18234       break;
18235     case GNU_BUILD_ATTRIBUTE_RELRO:
18236       text = _("<relro>");
18237       expected_types = bool_expected;
18238       ++ name;
18239       break;
18240     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18241       text = _("<stack size>");
18242       expected_types = number_expected;
18243       ++ name;
18244       break;
18245     case GNU_BUILD_ATTRIBUTE_TOOL:
18246       text = _("<tool>");
18247       expected_types = string_expected;
18248       ++ name;
18249       break;
18250     case GNU_BUILD_ATTRIBUTE_ABI:
18251       text = _("<ABI>");
18252       expected_types = "$*";
18253       ++ name;
18254       break;
18255     case GNU_BUILD_ATTRIBUTE_PIC:
18256       text = _("<PIC>");
18257       expected_types = number_expected;
18258       ++ name;
18259       break;
18260     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18261       text = _("<short enum>");
18262       expected_types = bool_expected;
18263       ++ name;
18264       break;
18265     default:
18266       if (ISPRINT (* name))
18267         {
18268           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18269
18270           if (len > left && ! do_wide)
18271             len = left;
18272           printf ("%.*s:", len, name);
18273           left -= len;
18274           name += len;
18275         }
18276       else
18277         {
18278           static char tmpbuf [128];
18279
18280           error (_("unrecognised byte in name field: %d\n"), * name);
18281           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18282           text = tmpbuf;
18283           name ++;
18284         }
18285       expected_types = "*$!+";
18286       break;
18287     }
18288
18289   if (text)
18290     left -= printf ("%s", text);
18291
18292   if (strchr (expected_types, name_type) == NULL)
18293     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18294
18295   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18296     {
18297       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18298              (unsigned long) pnote->namesz,
18299              (long) (name - pnote->namedata));
18300       return FALSE;
18301     }
18302
18303   if (left < 1 && ! do_wide)
18304     return TRUE;
18305
18306   switch (name_type)
18307     {
18308     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18309       {
18310         unsigned int        bytes;
18311         unsigned long long  val = 0;
18312         unsigned int        shift = 0;
18313         char *              decoded = NULL;
18314
18315         bytes = pnote->namesz - (name - pnote->namedata);
18316         if (bytes > 0)
18317           /* The -1 is because the name field is always 0 terminated, and we
18318              want to be able to ensure that the shift in the while loop below
18319              will not overflow.  */
18320           -- bytes;
18321
18322         if (bytes > sizeof (val))
18323           {
18324             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18325                    bytes);
18326             bytes = sizeof (val);
18327           }
18328         /* We do not bother to warn if bytes == 0 as this can
18329            happen with some early versions of the gcc plugin.  */
18330
18331         while (bytes --)
18332           {
18333             unsigned long byte = (* name ++) & 0xff;
18334
18335             val |= byte << shift;
18336             shift += 8;
18337           }
18338
18339         switch (name_attribute)
18340           {
18341           case GNU_BUILD_ATTRIBUTE_PIC:
18342             switch (val)
18343               {
18344               case 0: decoded = "static"; break;
18345               case 1: decoded = "pic"; break;
18346               case 2: decoded = "PIC"; break;
18347               case 3: decoded = "pie"; break;
18348               case 4: decoded = "PIE"; break;
18349               default: break;
18350               }
18351             break;
18352           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18353             switch (val)
18354               {
18355                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18356               case 0: decoded = "off"; break;
18357               case 1: decoded = "on"; break;
18358               case 2: decoded = "all"; break;
18359               case 3: decoded = "strong"; break;
18360               case 4: decoded = "explicit"; break;
18361               default: break;
18362               }
18363             break;
18364           default:
18365             break;
18366           }
18367
18368         if (decoded != NULL)
18369           {
18370             print_symbol (-left, decoded);
18371             left = 0;
18372           }
18373         else if (val == 0)
18374           {
18375             printf ("0x0");
18376             left -= 3;
18377           }
18378         else
18379           {
18380             if (do_wide)
18381               left -= printf ("0x%llx", val);
18382             else
18383               left -= printf ("0x%-.*llx", left, val);
18384           }
18385       }
18386       break;
18387     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18388       left -= print_symbol (- left, name);
18389       break;
18390     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18391       left -= print_symbol (- left, "true");
18392       break;
18393     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18394       left -= print_symbol (- left, "false");
18395       break;
18396     }
18397
18398   if (do_wide && left > 0)
18399     printf ("%-*s", left, " ");
18400
18401   return TRUE;
18402 }
18403
18404 /* Note that by the ELF standard, the name field is already null byte
18405    terminated, and namesz includes the terminating null byte.
18406    I.E. the value of namesz for the name "FSF" is 4.
18407
18408    If the value of namesz is zero, there is no name present.  */
18409
18410 static bfd_boolean
18411 process_note (Elf_Internal_Note *  pnote,
18412               Filedata *           filedata)
18413 {
18414   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18415   const char * nt;
18416
18417   if (pnote->namesz == 0)
18418     /* If there is no note name, then use the default set of
18419        note type strings.  */
18420     nt = get_note_type (filedata, pnote->type);
18421
18422   else if (const_strneq (pnote->namedata, "GNU"))
18423     /* GNU-specific object file notes.  */
18424     nt = get_gnu_elf_note_type (pnote->type);
18425
18426   else if (const_strneq (pnote->namedata, "FreeBSD"))
18427     /* FreeBSD-specific core file notes.  */
18428     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18429
18430   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18431     /* NetBSD-specific core file notes.  */
18432     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18433
18434   else if (const_strneq (pnote->namedata, "NetBSD"))
18435     /* NetBSD-specific core file notes.  */
18436     return process_netbsd_elf_note (pnote);
18437
18438   else if (strneq (pnote->namedata, "SPU/", 4))
18439     {
18440       /* SPU-specific core file notes.  */
18441       nt = pnote->namedata + 4;
18442       name = "SPU";
18443     }
18444
18445   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18446     /* VMS/ia64-specific file notes.  */
18447     nt = get_ia64_vms_note_type (pnote->type);
18448
18449   else if (const_strneq (pnote->namedata, "stapsdt"))
18450     nt = get_stapsdt_note_type (pnote->type);
18451
18452   else
18453     /* Don't recognize this note name; just use the default set of
18454        note type strings.  */
18455     nt = get_note_type (filedata, pnote->type);
18456
18457   printf ("  ");
18458
18459   if (((const_strneq (pnote->namedata, "GA")
18460         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18461        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18462       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18463           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18464     print_gnu_build_attribute_name (pnote);
18465   else
18466     print_symbol (-20, name);
18467
18468   if (do_wide)
18469     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18470   else
18471     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18472
18473   if (const_strneq (pnote->namedata, "IPF/VMS"))
18474     return print_ia64_vms_note (pnote);
18475   else if (const_strneq (pnote->namedata, "GNU"))
18476     return print_gnu_note (filedata, pnote);
18477   else if (const_strneq (pnote->namedata, "stapsdt"))
18478     return print_stapsdt_note (pnote);
18479   else if (const_strneq (pnote->namedata, "CORE"))
18480     return print_core_note (pnote);
18481   else if (((const_strneq (pnote->namedata, "GA")
18482              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18483             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18484            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18485                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18486     return print_gnu_build_attribute_description (pnote, filedata);
18487
18488   if (pnote->descsz)
18489     {
18490       unsigned long i;
18491
18492       printf (_("   description data: "));
18493       for (i = 0; i < pnote->descsz; i++)
18494         printf ("%02x ", pnote->descdata[i]);
18495       if (!do_wide)
18496         printf ("\n");
18497     }
18498
18499   if (do_wide)
18500     printf ("\n");
18501
18502   return TRUE;
18503 }
18504
18505 static bfd_boolean
18506 process_notes_at (Filedata *           filedata,
18507                   Elf_Internal_Shdr *  section,
18508                   bfd_vma              offset,
18509                   bfd_vma              length,
18510                   bfd_vma              align)
18511 {
18512   Elf_External_Note * pnotes;
18513   Elf_External_Note * external;
18514   char *              end;
18515   bfd_boolean         res = TRUE;
18516
18517   if (length <= 0)
18518     return FALSE;
18519
18520   if (section)
18521     {
18522       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18523       if (pnotes)
18524         {
18525           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18526             return FALSE;
18527         }
18528     }
18529   else
18530     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18531                                              _("notes"));
18532
18533   if (pnotes == NULL)
18534     return FALSE;
18535
18536   external = pnotes;
18537
18538   if (section)
18539     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18540   else
18541     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18542             (unsigned long) offset, (unsigned long) length);
18543
18544   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18545      specifies that notes should be aligned to 4 bytes in 32-bit
18546      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18547      we also support 4 byte alignment in 64-bit objects.  If section
18548      alignment is less than 4, we treate alignment as 4 bytes.   */
18549   if (align < 4)
18550     align = 4;
18551   else if (align != 4 && align != 8)
18552     {
18553       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18554             (long) align);
18555       return FALSE;
18556     }
18557
18558   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18559
18560   end = (char *) pnotes + length;
18561   while ((char *) external < end)
18562     {
18563       Elf_Internal_Note inote;
18564       size_t min_notesz;
18565       char * next;
18566       char * temp = NULL;
18567       size_t data_remaining = end - (char *) external;
18568
18569       if (!is_ia64_vms (filedata))
18570         {
18571           /* PR binutils/15191
18572              Make sure that there is enough data to read.  */
18573           min_notesz = offsetof (Elf_External_Note, name);
18574           if (data_remaining < min_notesz)
18575             {
18576               warn (ngettext ("Corrupt note: only %ld byte remains, "
18577                               "not enough for a full note\n",
18578                               "Corrupt note: only %ld bytes remain, "
18579                               "not enough for a full note\n",
18580                               data_remaining),
18581                     (long) data_remaining);
18582               break;
18583             }
18584           data_remaining -= min_notesz;
18585
18586           inote.type     = BYTE_GET (external->type);
18587           inote.namesz   = BYTE_GET (external->namesz);
18588           inote.namedata = external->name;
18589           inote.descsz   = BYTE_GET (external->descsz);
18590           inote.descdata = ((char *) external
18591                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18592           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18593           next = ((char *) external
18594                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18595         }
18596       else
18597         {
18598           Elf64_External_VMS_Note *vms_external;
18599
18600           /* PR binutils/15191
18601              Make sure that there is enough data to read.  */
18602           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18603           if (data_remaining < min_notesz)
18604             {
18605               warn (ngettext ("Corrupt note: only %ld byte remains, "
18606                               "not enough for a full note\n",
18607                               "Corrupt note: only %ld bytes remain, "
18608                               "not enough for a full note\n",
18609                               data_remaining),
18610                     (long) data_remaining);
18611               break;
18612             }
18613           data_remaining -= min_notesz;
18614
18615           vms_external = (Elf64_External_VMS_Note *) external;
18616           inote.type     = BYTE_GET (vms_external->type);
18617           inote.namesz   = BYTE_GET (vms_external->namesz);
18618           inote.namedata = vms_external->name;
18619           inote.descsz   = BYTE_GET (vms_external->descsz);
18620           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18621           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18622           next = inote.descdata + align_power (inote.descsz, 3);
18623         }
18624
18625       /* PR 17531: file: 3443835e.  */
18626       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18627       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18628           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18629           || (size_t) (next - inote.descdata) < inote.descsz
18630           || ((size_t) (next - inote.descdata)
18631               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18632         {
18633           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18634                 (unsigned long) ((char *) external - (char *) pnotes));
18635           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18636                 inote.type, inote.namesz, inote.descsz, (int) align);
18637           break;
18638         }
18639
18640       external = (Elf_External_Note *) next;
18641
18642       /* Verify that name is null terminated.  It appears that at least
18643          one version of Linux (RedHat 6.0) generates corefiles that don't
18644          comply with the ELF spec by failing to include the null byte in
18645          namesz.  */
18646       if (inote.namedata[inote.namesz - 1] != '\0')
18647         {
18648           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18649             {
18650               temp = (char *) malloc (inote.namesz + 1);
18651               if (temp == NULL)
18652                 {
18653                   error (_("Out of memory allocating space for inote name\n"));
18654                   res = FALSE;
18655                   break;
18656                 }
18657
18658               memcpy (temp, inote.namedata, inote.namesz);
18659               inote.namedata = temp;
18660             }
18661           inote.namedata[inote.namesz] = 0;
18662         }
18663
18664       if (! process_note (& inote, filedata))
18665         res = FALSE;
18666
18667       if (temp != NULL)
18668         {
18669           free (temp);
18670           temp = NULL;
18671         }
18672     }
18673
18674   free (pnotes);
18675
18676   return res;
18677 }
18678
18679 static bfd_boolean
18680 process_corefile_note_segments (Filedata * filedata)
18681 {
18682   Elf_Internal_Phdr * segment;
18683   unsigned int i;
18684   bfd_boolean res = TRUE;
18685
18686   if (! get_program_headers (filedata))
18687     return TRUE;
18688
18689   for (i = 0, segment = filedata->program_headers;
18690        i < filedata->file_header.e_phnum;
18691        i++, segment++)
18692     {
18693       if (segment->p_type == PT_NOTE)
18694         if (! process_notes_at (filedata, NULL,
18695                                 (bfd_vma) segment->p_offset,
18696                                 (bfd_vma) segment->p_filesz,
18697                                 (bfd_vma) segment->p_align))
18698           res = FALSE;
18699     }
18700
18701   return res;
18702 }
18703
18704 static bfd_boolean
18705 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18706 {
18707   Elf_External_Note * pnotes;
18708   Elf_External_Note * external;
18709   char * end;
18710   bfd_boolean res = TRUE;
18711
18712   if (length <= 0)
18713     return FALSE;
18714
18715   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18716                                            _("v850 notes"));
18717   if (pnotes == NULL)
18718     return FALSE;
18719
18720   external = pnotes;
18721   end = (char*) pnotes + length;
18722
18723   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18724           (unsigned long) offset, (unsigned long) length);
18725
18726   while ((char *) external + sizeof (Elf_External_Note) < end)
18727     {
18728       Elf_External_Note * next;
18729       Elf_Internal_Note inote;
18730
18731       inote.type     = BYTE_GET (external->type);
18732       inote.namesz   = BYTE_GET (external->namesz);
18733       inote.namedata = external->name;
18734       inote.descsz   = BYTE_GET (external->descsz);
18735       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18736       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18737
18738       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18739         {
18740           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18741           inote.descdata = inote.namedata;
18742           inote.namesz   = 0;
18743         }
18744
18745       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18746
18747       if (   ((char *) next > end)
18748           || ((char *) next <  (char *) pnotes))
18749         {
18750           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18751                 (unsigned long) ((char *) external - (char *) pnotes));
18752           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18753                 inote.type, inote.namesz, inote.descsz);
18754           break;
18755         }
18756
18757       external = next;
18758
18759       /* Prevent out-of-bounds indexing.  */
18760       if (   inote.namedata + inote.namesz > end
18761           || inote.namedata + inote.namesz < inote.namedata)
18762         {
18763           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18764                 (unsigned long) ((char *) external - (char *) pnotes));
18765           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18766                 inote.type, inote.namesz, inote.descsz);
18767           break;
18768         }
18769
18770       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18771
18772       if (! print_v850_note (& inote))
18773         {
18774           res = FALSE;
18775           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18776                   inote.namesz, inote.descsz);
18777         }
18778     }
18779
18780   free (pnotes);
18781
18782   return res;
18783 }
18784
18785 static bfd_boolean
18786 process_note_sections (Filedata * filedata)
18787 {
18788   Elf_Internal_Shdr * section;
18789   unsigned long i;
18790   unsigned int n = 0;
18791   bfd_boolean res = TRUE;
18792
18793   for (i = 0, section = filedata->section_headers;
18794        i < filedata->file_header.e_shnum && section != NULL;
18795        i++, section++)
18796     {
18797       if (section->sh_type == SHT_NOTE)
18798         {
18799           if (! process_notes_at (filedata, section,
18800                                   (bfd_vma) section->sh_offset,
18801                                   (bfd_vma) section->sh_size,
18802                                   (bfd_vma) section->sh_addralign))
18803             res = FALSE;
18804           n++;
18805         }
18806
18807       if ((   filedata->file_header.e_machine == EM_V800
18808            || filedata->file_header.e_machine == EM_V850
18809            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18810           && section->sh_type == SHT_RENESAS_INFO)
18811         {
18812           if (! process_v850_notes (filedata,
18813                                     (bfd_vma) section->sh_offset,
18814                                     (bfd_vma) section->sh_size))
18815             res = FALSE;
18816           n++;
18817         }
18818     }
18819
18820   if (n == 0)
18821     /* Try processing NOTE segments instead.  */
18822     return process_corefile_note_segments (filedata);
18823
18824   return res;
18825 }
18826
18827 static bfd_boolean
18828 process_notes (Filedata * filedata)
18829 {
18830   /* If we have not been asked to display the notes then do nothing.  */
18831   if (! do_notes)
18832     return TRUE;
18833
18834   if (filedata->file_header.e_type != ET_CORE)
18835     return process_note_sections (filedata);
18836
18837   /* No program headers means no NOTE segment.  */
18838   if (filedata->file_header.e_phnum > 0)
18839     return process_corefile_note_segments (filedata);
18840
18841   printf (_("No note segments present in the core file.\n"));
18842   return TRUE;
18843 }
18844
18845 static unsigned char *
18846 display_public_gnu_attributes (unsigned char * start,
18847                                const unsigned char * const end)
18848 {
18849   printf (_("  Unknown GNU attribute: %s\n"), start);
18850
18851   start += strnlen ((char *) start, end - start);
18852   display_raw_attribute (start, end);
18853
18854   return (unsigned char *) end;
18855 }
18856
18857 static unsigned char *
18858 display_generic_attribute (unsigned char * start,
18859                            unsigned int tag,
18860                            const unsigned char * const end)
18861 {
18862   if (tag == 0)
18863     return (unsigned char *) end;
18864
18865   return display_tag_value (tag, start, end);
18866 }
18867
18868 static bfd_boolean
18869 process_arch_specific (Filedata * filedata)
18870 {
18871   if (! do_arch)
18872     return TRUE;
18873
18874   switch (filedata->file_header.e_machine)
18875     {
18876     case EM_ARC:
18877     case EM_ARC_COMPACT:
18878     case EM_ARC_COMPACT2:
18879       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18880                                  display_arc_attribute,
18881                                  display_generic_attribute);
18882     case EM_ARM:
18883       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18884                                  display_arm_attribute,
18885                                  display_generic_attribute);
18886
18887     case EM_MIPS:
18888     case EM_MIPS_RS3_LE:
18889       return process_mips_specific (filedata);
18890
18891     case EM_MSP430:
18892      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18893                                 display_msp430x_attribute,
18894                                 display_generic_attribute);
18895
18896     case EM_NDS32:
18897       return process_nds32_specific (filedata);
18898
18899     case EM_PPC:
18900     case EM_PPC64:
18901       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18902                                  display_power_gnu_attribute);
18903
18904     case EM_S390:
18905     case EM_S390_OLD:
18906       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18907                                  display_s390_gnu_attribute);
18908
18909     case EM_SPARC:
18910     case EM_SPARC32PLUS:
18911     case EM_SPARCV9:
18912       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18913                                  display_sparc_gnu_attribute);
18914
18915     case EM_TI_C6000:
18916       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18917                                  display_tic6x_attribute,
18918                                  display_generic_attribute);
18919
18920     default:
18921       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18922                                  display_public_gnu_attributes,
18923                                  display_generic_attribute);
18924     }
18925 }
18926
18927 static bfd_boolean
18928 get_file_header (Filedata * filedata)
18929 {
18930   /* Read in the identity array.  */
18931   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18932     return FALSE;
18933
18934   /* Determine how to read the rest of the header.  */
18935   switch (filedata->file_header.e_ident[EI_DATA])
18936     {
18937     default:
18938     case ELFDATANONE:
18939     case ELFDATA2LSB:
18940       byte_get = byte_get_little_endian;
18941       byte_put = byte_put_little_endian;
18942       break;
18943     case ELFDATA2MSB:
18944       byte_get = byte_get_big_endian;
18945       byte_put = byte_put_big_endian;
18946       break;
18947     }
18948
18949   /* For now we only support 32 bit and 64 bit ELF files.  */
18950   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18951
18952   /* Read in the rest of the header.  */
18953   if (is_32bit_elf)
18954     {
18955       Elf32_External_Ehdr ehdr32;
18956
18957       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18958         return FALSE;
18959
18960       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18961       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18962       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18963       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18964       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18965       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18966       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18967       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18968       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18969       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18970       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18971       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18972       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18973     }
18974   else
18975     {
18976       Elf64_External_Ehdr ehdr64;
18977
18978       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18979          we will not be able to cope with the 64bit data found in
18980          64 ELF files.  Detect this now and abort before we start
18981          overwriting things.  */
18982       if (sizeof (bfd_vma) < 8)
18983         {
18984           error (_("This instance of readelf has been built without support for a\n\
18985 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18986           return FALSE;
18987         }
18988
18989       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18990         return FALSE;
18991
18992       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18993       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18994       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18995       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18996       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18997       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18998       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18999       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19000       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19001       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19002       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19003       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19004       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19005     }
19006
19007   if (filedata->file_header.e_shoff)
19008     {
19009       /* There may be some extensions in the first section header.  Don't
19010          bomb if we can't read it.  */
19011       if (is_32bit_elf)
19012         get_32bit_section_headers (filedata, TRUE);
19013       else
19014         get_64bit_section_headers (filedata, TRUE);
19015     }
19016
19017   return TRUE;
19018 }
19019
19020 static void
19021 close_file (Filedata * filedata)
19022 {
19023   if (filedata)
19024     {
19025       if (filedata->handle)
19026         fclose (filedata->handle);
19027       free (filedata);
19028     }
19029 }
19030
19031 void
19032 close_debug_file (void * data)
19033 {
19034   close_file ((Filedata *) data);
19035 }
19036
19037 static Filedata *
19038 open_file (const char * pathname)
19039 {
19040   struct stat  statbuf;
19041   Filedata *   filedata = NULL;
19042
19043   if (stat (pathname, & statbuf) < 0
19044       || ! S_ISREG (statbuf.st_mode))
19045     goto fail;
19046
19047   filedata = calloc (1, sizeof * filedata);
19048   if (filedata == NULL)
19049     goto fail;
19050
19051   filedata->handle = fopen (pathname, "rb");
19052   if (filedata->handle == NULL)
19053     goto fail;
19054
19055   filedata->file_size = (bfd_size_type) statbuf.st_size;
19056   filedata->file_name = pathname;
19057
19058   if (! get_file_header (filedata))
19059     goto fail;
19060
19061   if (filedata->file_header.e_shoff)
19062     {
19063       bfd_boolean res;
19064
19065       /* Read the section headers again, this time for real.  */
19066       if (is_32bit_elf)
19067         res = get_32bit_section_headers (filedata, FALSE);
19068       else
19069         res = get_64bit_section_headers (filedata, FALSE);
19070
19071       if (!res)
19072         goto fail;
19073     }
19074
19075   return filedata;
19076
19077  fail:
19078   if (filedata)
19079     {
19080       if (filedata->handle)
19081         fclose (filedata->handle);
19082       free (filedata);
19083     }
19084   return NULL;
19085 }
19086
19087 void *
19088 open_debug_file (const char * pathname)
19089 {
19090   return open_file (pathname);
19091 }
19092
19093 /* Process one ELF object file according to the command line options.
19094    This file may actually be stored in an archive.  The file is
19095    positioned at the start of the ELF object.  Returns TRUE if no
19096    problems were encountered, FALSE otherwise.  */
19097
19098 static bfd_boolean
19099 process_object (Filedata * filedata)
19100 {
19101   Filedata * separates;
19102   unsigned int i;
19103   bfd_boolean res = TRUE;
19104
19105   if (! get_file_header (filedata))
19106     {
19107       error (_("%s: Failed to read file header\n"), filedata->file_name);
19108       return FALSE;
19109     }
19110
19111   /* Initialise per file variables.  */
19112   for (i = ARRAY_SIZE (version_info); i--;)
19113     version_info[i] = 0;
19114
19115   for (i = ARRAY_SIZE (dynamic_info); i--;)
19116     dynamic_info[i] = 0;
19117   dynamic_info_DT_GNU_HASH = 0;
19118
19119   /* Process the file.  */
19120   if (show_name)
19121     printf (_("\nFile: %s\n"), filedata->file_name);
19122
19123   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19124      Note we do this even if cmdline_dump_sects is empty because we
19125      must make sure that the dump_sets array is zeroed out before each
19126      object file is processed.  */
19127   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19128     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19129
19130   if (cmdline.num_dump_sects > 0)
19131     {
19132       if (filedata->num_dump_sects == 0)
19133         /* A sneaky way of allocating the dump_sects array.  */
19134         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19135
19136       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19137       memcpy (filedata->dump_sects, cmdline.dump_sects,
19138               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19139     }
19140
19141   if (! process_file_header (filedata))
19142     return FALSE;
19143
19144   if (! process_section_headers (filedata))
19145     {
19146       /* Without loaded section headers we cannot process lots of things.  */
19147       do_unwind = do_version = do_dump = do_arch = FALSE;
19148
19149       if (! do_using_dynamic)
19150         do_syms = do_dyn_syms = do_reloc = FALSE;
19151     }
19152
19153   if (! process_section_groups (filedata))
19154     /* Without loaded section groups we cannot process unwind.  */
19155     do_unwind = FALSE;
19156
19157   if (process_program_headers (filedata))
19158     process_dynamic_section (filedata);
19159   else
19160     res = FALSE;
19161
19162   if (! process_relocs (filedata))
19163     res = FALSE;
19164
19165   if (! process_unwind (filedata))
19166     res = FALSE;
19167
19168   if (! process_symbol_table (filedata))
19169     res = FALSE;
19170
19171   if (! process_syminfo (filedata))
19172     res = FALSE;
19173
19174   if (! process_version_sections (filedata))
19175     res = FALSE;
19176
19177   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19178     separates = load_separate_debug_file (filedata, filedata->file_name);
19179   else
19180     separates = NULL;
19181
19182   if (! process_section_contents (filedata))
19183     res = FALSE;
19184
19185   if (separates)
19186     {
19187       if (! process_section_headers (separates))
19188         res = FALSE;
19189       else if (! process_section_contents (separates))
19190         res = FALSE;
19191     }
19192
19193   if (! process_notes (filedata))
19194     res = FALSE;
19195
19196   if (! process_gnu_liblist (filedata))
19197     res = FALSE;
19198
19199   if (! process_arch_specific (filedata))
19200     res = FALSE;
19201
19202   free (filedata->program_headers);
19203   filedata->program_headers = NULL;
19204
19205   free (filedata->section_headers);
19206   filedata->section_headers = NULL;
19207
19208   free (filedata->string_table);
19209   filedata->string_table = NULL;
19210   filedata->string_table_length = 0;
19211
19212   if (dynamic_strings)
19213     {
19214       free (dynamic_strings);
19215       dynamic_strings = NULL;
19216       dynamic_strings_length = 0;
19217     }
19218
19219   if (dynamic_symbols)
19220     {
19221       free (dynamic_symbols);
19222       dynamic_symbols = NULL;
19223       num_dynamic_syms = 0;
19224     }
19225
19226   if (dynamic_syminfo)
19227     {
19228       free (dynamic_syminfo);
19229       dynamic_syminfo = NULL;
19230     }
19231
19232   if (dynamic_section)
19233     {
19234       free (dynamic_section);
19235       dynamic_section = NULL;
19236     }
19237
19238   if (section_headers_groups)
19239     {
19240       free (section_headers_groups);
19241       section_headers_groups = NULL;
19242     }
19243
19244   if (section_groups)
19245     {
19246       struct group_list * g;
19247       struct group_list * next;
19248
19249       for (i = 0; i < group_count; i++)
19250         {
19251           for (g = section_groups [i].root; g != NULL; g = next)
19252             {
19253               next = g->next;
19254               free (g);
19255             }
19256         }
19257
19258       free (section_groups);
19259       section_groups = NULL;
19260     }
19261
19262   free_debug_memory ();
19263
19264   return res;
19265 }
19266
19267 /* Process an ELF archive.
19268    On entry the file is positioned just after the ARMAG string.
19269    Returns TRUE upon success, FALSE otherwise.  */
19270
19271 static bfd_boolean
19272 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19273 {
19274   struct archive_info arch;
19275   struct archive_info nested_arch;
19276   size_t got;
19277   bfd_boolean ret = TRUE;
19278
19279   show_name = TRUE;
19280
19281   /* The ARCH structure is used to hold information about this archive.  */
19282   arch.file_name = NULL;
19283   arch.file = NULL;
19284   arch.index_array = NULL;
19285   arch.sym_table = NULL;
19286   arch.longnames = NULL;
19287
19288   /* The NESTED_ARCH structure is used as a single-item cache of information
19289      about a nested archive (when members of a thin archive reside within
19290      another regular archive file).  */
19291   nested_arch.file_name = NULL;
19292   nested_arch.file = NULL;
19293   nested_arch.index_array = NULL;
19294   nested_arch.sym_table = NULL;
19295   nested_arch.longnames = NULL;
19296
19297   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19298                      is_thin_archive, do_archive_index) != 0)
19299     {
19300       ret = FALSE;
19301       goto out;
19302     }
19303
19304   if (do_archive_index)
19305     {
19306       if (arch.sym_table == NULL)
19307         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19308       else
19309         {
19310           unsigned long i, l;
19311           unsigned long current_pos;
19312
19313           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19314                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19315
19316           current_pos = ftell (filedata->handle);
19317
19318           for (i = l = 0; i < arch.index_num; i++)
19319             {
19320               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19321                 {
19322                   char * member_name;
19323
19324                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19325
19326                   if (member_name != NULL)
19327                     {
19328                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19329
19330                       if (qualified_name != NULL)
19331                         {
19332                           printf (_("Contents of binary %s at offset "), qualified_name);
19333                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19334                           putchar ('\n');
19335                           free (qualified_name);
19336                         }
19337                     }
19338                 }
19339
19340               if (l >= arch.sym_size)
19341                 {
19342                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19343                          filedata->file_name);
19344                   ret = FALSE;
19345                   break;
19346                 }
19347               /* PR 17531: file: 0b6630b2.  */
19348               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19349               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19350             }
19351
19352           if (arch.uses_64bit_indices)
19353             l = (l + 7) & ~ 7;
19354           else
19355             l += l & 1;
19356
19357           if (l < arch.sym_size)
19358             {
19359               error (ngettext ("%s: %ld byte remains in the symbol table, "
19360                                "but without corresponding entries in "
19361                                "the index table\n",
19362                                "%s: %ld bytes remain in the symbol table, "
19363                                "but without corresponding entries in "
19364                                "the index table\n",
19365                                arch.sym_size - l),
19366                      filedata->file_name, arch.sym_size - l);
19367               ret = FALSE;
19368             }
19369
19370           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19371             {
19372               error (_("%s: failed to seek back to start of object files in the archive\n"),
19373                      filedata->file_name);
19374               ret = FALSE;
19375               goto out;
19376             }
19377         }
19378
19379       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19380           && !do_segments && !do_header && !do_dump && !do_version
19381           && !do_histogram && !do_debugging && !do_arch && !do_notes
19382           && !do_section_groups && !do_dyn_syms)
19383         {
19384           ret = TRUE; /* Archive index only.  */
19385           goto out;
19386         }
19387     }
19388
19389   while (1)
19390     {
19391       char * name;
19392       size_t namelen;
19393       char * qualified_name;
19394
19395       /* Read the next archive header.  */
19396       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19397         {
19398           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19399           return FALSE;
19400         }
19401       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19402       if (got != sizeof arch.arhdr)
19403         {
19404           if (got == 0)
19405             break;
19406           error (_("%s: failed to read archive header\n"), filedata->file_name);
19407           ret = FALSE;
19408           break;
19409         }
19410       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19411         {
19412           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19413           ret = FALSE;
19414           break;
19415         }
19416
19417       arch.next_arhdr_offset += sizeof arch.arhdr;
19418
19419       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19420       if (archive_file_size & 01)
19421         ++archive_file_size;
19422
19423       name = get_archive_member_name (&arch, &nested_arch);
19424       if (name == NULL)
19425         {
19426           error (_("%s: bad archive file name\n"), filedata->file_name);
19427           ret = FALSE;
19428           break;
19429         }
19430       namelen = strlen (name);
19431
19432       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19433       if (qualified_name == NULL)
19434         {
19435           error (_("%s: bad archive file name\n"), filedata->file_name);
19436           ret = FALSE;
19437           break;
19438         }
19439
19440       if (is_thin_archive && arch.nested_member_origin == 0)
19441         {
19442           /* This is a proxy for an external member of a thin archive.  */
19443           Filedata * member_filedata;
19444           char * member_file_name = adjust_relative_path
19445             (filedata->file_name, name, namelen);
19446
19447           if (member_file_name == NULL)
19448             {
19449               ret = FALSE;
19450               break;
19451             }
19452
19453           member_filedata = open_file (member_file_name);
19454           if (member_filedata == NULL)
19455             {
19456               error (_("Input file '%s' is not readable.\n"), member_file_name);
19457               free (member_file_name);
19458               ret = FALSE;
19459               break;
19460             }
19461
19462           archive_file_offset = arch.nested_member_origin;
19463           member_filedata->file_name = qualified_name;
19464
19465           if (! process_object (member_filedata))
19466             ret = FALSE;
19467
19468           close_file (member_filedata);
19469           free (member_file_name);
19470         }
19471       else if (is_thin_archive)
19472         {
19473           Filedata thin_filedata;
19474
19475           memset (&thin_filedata, 0, sizeof (thin_filedata));
19476
19477           /* PR 15140: Allow for corrupt thin archives.  */
19478           if (nested_arch.file == NULL)
19479             {
19480               error (_("%s: contains corrupt thin archive: %s\n"),
19481                      filedata->file_name, name);
19482               ret = FALSE;
19483               break;
19484             }
19485
19486           /* This is a proxy for a member of a nested archive.  */
19487           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19488
19489           /* The nested archive file will have been opened and setup by
19490              get_archive_member_name.  */
19491           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19492             {
19493               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19494               ret = FALSE;
19495               break;
19496             }
19497
19498           thin_filedata.handle = nested_arch.file;
19499           thin_filedata.file_name = qualified_name;
19500
19501           if (! process_object (& thin_filedata))
19502             ret = FALSE;
19503         }
19504       else
19505         {
19506           archive_file_offset = arch.next_arhdr_offset;
19507           arch.next_arhdr_offset += archive_file_size;
19508
19509           filedata->file_name = qualified_name;
19510           if (! process_object (filedata))
19511             ret = FALSE;
19512         }
19513
19514       if (filedata->dump_sects != NULL)
19515         {
19516           free (filedata->dump_sects);
19517           filedata->dump_sects = NULL;
19518           filedata->num_dump_sects = 0;
19519         }
19520
19521       free (qualified_name);
19522     }
19523
19524  out:
19525   if (nested_arch.file != NULL)
19526     fclose (nested_arch.file);
19527   release_archive (&nested_arch);
19528   release_archive (&arch);
19529
19530   return ret;
19531 }
19532
19533 static bfd_boolean
19534 process_file (char * file_name)
19535 {
19536   Filedata * filedata = NULL;
19537   struct stat statbuf;
19538   char armag[SARMAG];
19539   bfd_boolean ret = TRUE;
19540
19541   if (stat (file_name, &statbuf) < 0)
19542     {
19543       if (errno == ENOENT)
19544         error (_("'%s': No such file\n"), file_name);
19545       else
19546         error (_("Could not locate '%s'.  System error message: %s\n"),
19547                file_name, strerror (errno));
19548       return FALSE;
19549     }
19550
19551   if (! S_ISREG (statbuf.st_mode))
19552     {
19553       error (_("'%s' is not an ordinary file\n"), file_name);
19554       return FALSE;
19555     }
19556
19557   filedata = calloc (1, sizeof * filedata);
19558   if (filedata == NULL)
19559     {
19560       error (_("Out of memory allocating file data structure\n"));
19561       return FALSE;
19562     }
19563
19564   filedata->file_name = file_name;
19565   filedata->handle = fopen (file_name, "rb");
19566   if (filedata->handle == NULL)
19567     {
19568       error (_("Input file '%s' is not readable.\n"), file_name);
19569       free (filedata);
19570       return FALSE;
19571     }
19572
19573   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19574     {
19575       error (_("%s: Failed to read file's magic number\n"), file_name);
19576       fclose (filedata->handle);
19577       free (filedata);
19578       return FALSE;
19579     }
19580
19581   filedata->file_size = (bfd_size_type) statbuf.st_size;
19582
19583   if (memcmp (armag, ARMAG, SARMAG) == 0)
19584     {
19585       if (! process_archive (filedata, FALSE))
19586         ret = FALSE;
19587     }
19588   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19589     {
19590       if ( ! process_archive (filedata, TRUE))
19591         ret = FALSE;
19592     }
19593   else
19594     {
19595       if (do_archive_index)
19596         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19597                file_name);
19598
19599       rewind (filedata->handle);
19600       archive_file_size = archive_file_offset = 0;
19601
19602       if (! process_object (filedata))
19603         ret = FALSE;
19604     }
19605
19606   fclose (filedata->handle);
19607   free (filedata);
19608
19609   return ret;
19610 }
19611
19612 #ifdef SUPPORT_DISASSEMBLY
19613 /* Needed by the i386 disassembler.  For extra credit, someone could
19614    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19615    symbols.  */
19616
19617 void
19618 print_address (unsigned int addr, FILE * outfile)
19619 {
19620   fprintf (outfile,"0x%8.8x", addr);
19621 }
19622
19623 /* Needed by the i386 disassembler.  */
19624
19625 void
19626 db_task_printsym (unsigned int addr)
19627 {
19628   print_address (addr, stderr);
19629 }
19630 #endif
19631
19632 int
19633 main (int argc, char ** argv)
19634 {
19635   int err;
19636
19637 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19638   setlocale (LC_MESSAGES, "");
19639 #endif
19640 #if defined (HAVE_SETLOCALE)
19641   setlocale (LC_CTYPE, "");
19642 #endif
19643   bindtextdomain (PACKAGE, LOCALEDIR);
19644   textdomain (PACKAGE);
19645
19646   expandargv (&argc, &argv);
19647
19648   cmdline.file_name = "<cmdline>";
19649   parse_args (& cmdline, argc, argv);
19650
19651   if (optind < (argc - 1))
19652     show_name = TRUE;
19653   else if (optind >= argc)
19654     {
19655       warn (_("Nothing to do.\n"));
19656       usage (stderr);
19657     }
19658
19659   err = FALSE;
19660   while (optind < argc)
19661     if (! process_file (argv[optind++]))
19662       err = TRUE;
19663
19664   if (cmdline.dump_sects != NULL)
19665     free (cmdline.dump_sects);
19666
19667   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19668 }