binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2017 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/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/riscv.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nds32.h"
 135 #include "elf/nios2.h"
 136 #include "elf/or1k.h"
 137 #include "elf/pj.h"
 138 #include "elf/ppc.h"
 139 #include "elf/ppc64.h"
 140 #include "elf/pru.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/wasm32.h"
 155 #include "elf/x86-64.h"
 156 #include "elf/xc16x.h"
 157 #include "elf/xgate.h"
 158 #include "elf/xstormy16.h"
 159 #include "elf/xtensa.h"
 160
 161 #include "getopt.h"
 162 #include "libiberty.h"
 163 #include "safe-ctype.h"
 164 #include "filenames.h"
 165
 166 #ifndef offsetof
 167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 168 #endif
 169
 170 typedef struct elf_section_list
 171 {
 172   Elf_Internal_Shdr * hdr;
 173   struct elf_section_list * next;
 174 } elf_section_list;
 175
 176 char * program_name = "readelf";
 177 static unsigned long archive_file_offset;
 178 static unsigned long archive_file_size;
 179 static bfd_size_type current_file_size;
 180 static unsigned long dynamic_addr;
 181 static bfd_size_type dynamic_size;
 182 static size_t dynamic_nent;
 183 static char * dynamic_strings;
 184 static unsigned long dynamic_strings_length;
 185 static char * string_table;
 186 static unsigned long string_table_length;
 187 static unsigned long num_dynamic_syms;
 188 static Elf_Internal_Sym * dynamic_symbols;
 189 static Elf_Internal_Syminfo * dynamic_syminfo;
 190 static unsigned long dynamic_syminfo_offset;
 191 static unsigned int dynamic_syminfo_nent;
 192 static char program_interpreter[PATH_MAX];
 193 static bfd_vma dynamic_info[DT_ENCODING];
 194 static bfd_vma dynamic_info_DT_GNU_HASH;
 195 static bfd_vma version_info[16];
 196 static Elf_Internal_Ehdr elf_header;
 197 static Elf_Internal_Shdr * section_headers;
 198 static Elf_Internal_Phdr * program_headers;
 199 static Elf_Internal_Dyn *  dynamic_section;
 200 static elf_section_list * symtab_shndx_list;
 201 static bfd_boolean show_name = FALSE;
 202 static bfd_boolean do_dynamic = FALSE;
 203 static bfd_boolean do_syms = FALSE;
 204 static bfd_boolean do_dyn_syms = FALSE;
 205 static bfd_boolean do_reloc = FALSE;
 206 static bfd_boolean do_sections = FALSE;
 207 static bfd_boolean do_section_groups = FALSE;
 208 static bfd_boolean do_section_details = FALSE;
 209 static bfd_boolean do_segments = FALSE;
 210 static bfd_boolean do_unwind = FALSE;
 211 static bfd_boolean do_using_dynamic = FALSE;
 212 static bfd_boolean do_header = FALSE;
 213 static bfd_boolean do_dump = FALSE;
 214 static bfd_boolean do_version = FALSE;
 215 static bfd_boolean do_histogram = FALSE;
 216 static bfd_boolean do_debugging = FALSE;
 217 static bfd_boolean do_arch = FALSE;
 218 static bfd_boolean do_notes = FALSE;
 219 static bfd_boolean do_archive_index = FALSE;
 220 static bfd_boolean is_32bit_elf = FALSE;
 221 static bfd_boolean decompress_dumps = FALSE;
 222
 223 struct group_list
 224 {
 225   struct group_list * next;
 226   unsigned int section_index;
 227 };
 228
 229 struct group
 230 {
 231   struct group_list * root;
 232   unsigned int group_index;
 233 };
 234
 235 static size_t group_count;
 236 static struct group * section_groups;
 237 static struct group ** section_headers_groups;
 238
 239
 240 /* Flag bits indicating particular types of dump.  */
 241 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 242 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 243 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 244 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 245 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 246
 247 typedef unsigned char dump_type;
 248
 249 /* A linked list of the section names for which dumps were requested.  */
 250 struct dump_list_entry
 251 {
 252   char * name;
 253   dump_type type;
 254   struct dump_list_entry * next;
 255 };
 256 static struct dump_list_entry * dump_sects_byname;
 257
 258 /* A dynamic array of flags indicating for which sections a dump
 259    has been requested via command line switches.  */
 260 static dump_type *   cmdline_dump_sects = NULL;
 261 static unsigned int  num_cmdline_dump_sects = 0;
 262
 263 /* A dynamic array of flags indicating for which sections a dump of
 264    some kind has been requested.  It is reset on a per-object file
 265    basis and then initialised from the cmdline_dump_sects array,
 266    the results of interpreting the -w switch, and the
 267    dump_sects_byname list.  */
 268 static dump_type *   dump_sects = NULL;
 269 static unsigned int  num_dump_sects = 0;
 270
 271
 272 /* How to print a vma value.  */
 273 typedef enum print_mode
 274 {
 275   HEX,
 276   DEC,
 277   DEC_5,
 278   UNSIGNED,
 279   PREFIX_HEX,
 280   FULL_HEX,
 281   LONG_HEX
 282 }
 283 print_mode;
 284
 285 /* Versioned symbol info.  */
 286 enum versioned_symbol_info
 287 {
 288   symbol_undefined,
 289   symbol_hidden,
 290   symbol_public
 291 };
 292
 293 static const char * get_symbol_version_string
 294   (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
 295    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 296
 297 #define UNKNOWN -1
 298
 299 #define SECTION_NAME(X)                                         \
 300   ((X) == NULL ? _("<none>")                                    \
 301    : string_table == NULL ? _("<no-name>")                      \
 302    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 303   : string_table + (X)->sh_name))
 304
 305 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 306
 307 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 308   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 309    : get_64bit_elf_symbols (file, section, sym_count))
 310
 311 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 313    already been called and verified that the string exists.  */
 314 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 315
 316 #define REMOVE_ARCH_BITS(ADDR)                  \
 317   do                                            \
 318     {                                           \
 319       if (elf_header.e_machine == EM_ARM)       \
 320         (ADDR) &= ~1;                           \
 321     }                                           \
 322   while (0)
 323 \f
 324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 325    the offset of the current archive member, if we are examining an archive.
 326    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 327    using malloc and fill that.  In either case return the pointer to the start of
 328    the retrieved data or NULL if something went wrong.  If something does go wrong
 329    and REASON is not NULL then emit an error message using REASON as part of the
 330    context.  */
 331
 332 static void *
 333 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 334           bfd_size_type nmemb, const char * reason)
 335 {
 336   void * mvar;
 337   bfd_size_type amt = size * nmemb;
 338
 339   if (size == 0 || nmemb == 0)
 340     return NULL;
 341
 342   /* If the size_t type is smaller than the bfd_size_type, eg because
 343      you are building a 32-bit tool on a 64-bit host, then make sure
 344      that when the sizes are cast to (size_t) no information is lost.  */
 345   if (sizeof (size_t) < sizeof (bfd_size_type)
 346       && (   (bfd_size_type) ((size_t) size) != size
 347           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 348     {
 349       if (reason)
 350         error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
 351                  " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
 352                nmemb, size, reason);
 353       return NULL;
 354     }
 355
 356   /* Check for size overflow.  */
 357   if (amt < nmemb)
 358     {
 359       if (reason)
 360         error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
 361                  " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
 362                nmemb, size, reason);
 363       return NULL;
 364     }
 365
 366   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 367      attempting to allocate memory when the read is bound to fail.  */
 368   if (amt > current_file_size
 369       || offset + archive_file_offset + amt > current_file_size)
 370     {
 371       if (reason)
 372         error (_("Reading 0x%" BFD_VMA_FMT "x"
 373                  " bytes extends past end of file for %s\n"),
 374                amt, reason);
 375       return NULL;
 376     }
 377
 378   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 379     {
 380       if (reason)
 381         error (_("Unable to seek to 0x%lx for %s\n"),
 382                archive_file_offset + offset, reason);
 383       return NULL;
 384     }
 385
 386   mvar = var;
 387   if (mvar == NULL)
 388     {
 389       /* Check for overflow.  */
 390       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 391         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 392         mvar = malloc ((size_t) amt + 1);
 393
 394       if (mvar == NULL)
 395         {
 396           if (reason)
 397             error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
 398                      " bytes for %s\n"),
 399                    amt, reason);
 400           return NULL;
 401         }
 402
 403       ((char *) mvar)[amt] = '\0';
 404     }
 405
 406   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 407     {
 408       if (reason)
 409         error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
 410                amt, reason);
 411       if (mvar != var)
 412         free (mvar);
 413       return NULL;
 414     }
 415
 416   return mvar;
 417 }
 418
 419 /* Print a VMA value in the MODE specified.
 420    Returns the number of characters displayed.  */
 421
 422 static unsigned int
 423 print_vma (bfd_vma vma, print_mode mode)
 424 {
 425   unsigned int nc = 0;
 426
 427   switch (mode)
 428     {
 429     case FULL_HEX:
 430       nc = printf ("0x");
 431       /* Fall through.  */
 432     case LONG_HEX:
 433 #ifdef BFD64
 434       if (is_32bit_elf)
 435         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 436 #endif
 437       printf_vma (vma);
 438       return nc + 16;
 439
 440     case DEC_5:
 441       if (vma <= 99999)
 442         return printf ("%5" BFD_VMA_FMT "d", vma);
 443       /* Fall through.  */
 444     case PREFIX_HEX:
 445       nc = printf ("0x");
 446       /* Fall through.  */
 447     case HEX:
 448       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 449
 450     case DEC:
 451       return printf ("%" BFD_VMA_FMT "d", vma);
 452
 453     case UNSIGNED:
 454       return printf ("%" BFD_VMA_FMT "u", vma);
 455
 456     default:
 457       /* FIXME: Report unrecognised mode ?  */
 458       return 0;
 459     }
 460 }
 461
 462 /* Display a symbol on stdout.  Handles the display of control characters and
 463    multibye characters (assuming the host environment supports them).
 464
 465    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 466
 467    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 468    padding as necessary.
 469
 470    Returns the number of emitted characters.  */
 471
 472 static unsigned int
 473 print_symbol (signed int width, const char *symbol)
 474 {
 475   bfd_boolean extra_padding = FALSE;
 476   signed int num_printed = 0;
 477 #ifdef HAVE_MBSTATE_T
 478   mbstate_t state;
 479 #endif
 480   unsigned int width_remaining;
 481
 482   if (width < 0)
 483     {
 484       /* Keep the width positive.  This helps the code below.  */
 485       width = - width;
 486       extra_padding = TRUE;
 487     }
 488   assert (width != 0);
 489
 490   if (do_wide)
 491     /* Set the remaining width to a very large value.
 492        This simplifies the code below.  */
 493     width_remaining = INT_MAX;
 494   else
 495     width_remaining = width;
 496
 497 #ifdef HAVE_MBSTATE_T
 498   /* Initialise the multibyte conversion state.  */
 499   memset (& state, 0, sizeof (state));
 500 #endif
 501
 502   while (width_remaining)
 503     {
 504       size_t  n;
 505       const char c = *symbol++;
 506
 507       if (c == 0)
 508         break;
 509
 510       /* Do not print control characters directly as they can affect terminal
 511          settings.  Such characters usually appear in the names generated
 512          by the assembler for local labels.  */
 513       if (ISCNTRL (c))
 514         {
 515           if (width_remaining < 2)
 516             break;
 517
 518           printf ("^%c", c + 0x40);
 519           width_remaining -= 2;
 520           num_printed += 2;
 521         }
 522       else if (ISPRINT (c))
 523         {
 524           putchar (c);
 525           width_remaining --;
 526           num_printed ++;
 527         }
 528       else
 529         {
 530 #ifdef HAVE_MBSTATE_T
 531           wchar_t w;
 532 #endif
 533           /* Let printf do the hard work of displaying multibyte characters.  */
 534           printf ("%.1s", symbol - 1);
 535           width_remaining --;
 536           num_printed ++;
 537
 538 #ifdef HAVE_MBSTATE_T
 539           /* Try to find out how many bytes made up the character that was
 540              just printed.  Advance the symbol pointer past the bytes that
 541              were displayed.  */
 542           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 543 #else
 544           n = 1;
 545 #endif
 546           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 547             symbol += (n - 1);
 548         }
 549     }
 550
 551   if (extra_padding && num_printed < width)
 552     {
 553       /* Fill in the remaining spaces.  */
 554       printf ("%-*s", width - num_printed, " ");
 555       num_printed = width;
 556     }
 557
 558   return num_printed;
 559 }
 560
 561 /* Returns a pointer to a static buffer containing a printable version of
 562    the given section's name.  Like print_symbol, except that it does not try
 563    to print multibyte characters, it just interprets them as hex values.  */
 564
 565 static const char *
 566 printable_section_name (const Elf_Internal_Shdr * sec)
 567 {
 568 #define MAX_PRINT_SEC_NAME_LEN 128
 569   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 570   const char * name = SECTION_NAME (sec);
 571   char *       buf = sec_name_buf;
 572   char         c;
 573   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 574
 575   while ((c = * name ++) != 0)
 576     {
 577       if (ISCNTRL (c))
 578         {
 579           if (remaining < 2)
 580             break;
 581
 582           * buf ++ = '^';
 583           * buf ++ = c + 0x40;
 584           remaining -= 2;
 585         }
 586       else if (ISPRINT (c))
 587         {
 588           * buf ++ = c;
 589           remaining -= 1;
 590         }
 591       else
 592         {
 593           static char hex[17] = "0123456789ABCDEF";
 594
 595           if (remaining < 4)
 596             break;
 597           * buf ++ = '<';
 598           * buf ++ = hex[(c & 0xf0) >> 4];
 599           * buf ++ = hex[c & 0x0f];
 600           * buf ++ = '>';
 601           remaining -= 4;
 602         }
 603
 604       if (remaining == 0)
 605         break;
 606     }
 607
 608   * buf = 0;
 609   return sec_name_buf;
 610 }
 611
 612 static const char *
 613 printable_section_name_from_index (unsigned long ndx)
 614 {
 615   if (ndx >= elf_header.e_shnum)
 616     return _("<corrupt>");
 617
 618   return printable_section_name (section_headers + ndx);
 619 }
 620
 621 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 622
 623 static Elf_Internal_Shdr *
 624 find_section (const char * name)
 625 {
 626   unsigned int i;
 627
 628   for (i = 0; i < elf_header.e_shnum; i++)
 629     if (streq (SECTION_NAME (section_headers + i), name))
 630       return section_headers + i;
 631
 632   return NULL;
 633 }
 634
 635 /* Return a pointer to a section containing ADDR, or NULL if no such
 636    section exists.  */
 637
 638 static Elf_Internal_Shdr *
 639 find_section_by_address (bfd_vma addr)
 640 {
 641   unsigned int i;
 642
 643   for (i = 0; i < elf_header.e_shnum; i++)
 644     {
 645       Elf_Internal_Shdr *sec = section_headers + i;
 646       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 647         return sec;
 648     }
 649
 650   return NULL;
 651 }
 652
 653 static Elf_Internal_Shdr *
 654 find_section_by_type (unsigned int type)
 655 {
 656   unsigned int i;
 657
 658   for (i = 0; i < elf_header.e_shnum; i++)
 659     {
 660       Elf_Internal_Shdr *sec = section_headers + i;
 661       if (sec->sh_type == type)
 662         return sec;
 663     }
 664
 665   return NULL;
 666 }
 667
 668 /* Return a pointer to section NAME, or NULL if no such section exists,
 669    restricted to the list of sections given in SET.  */
 670
 671 static Elf_Internal_Shdr *
 672 find_section_in_set (const char * name, unsigned int * set)
 673 {
 674   unsigned int i;
 675
 676   if (set != NULL)
 677     {
 678       while ((i = *set++) > 0)
 679         {
 680           /* See PR 21156 for a reproducer.  */
 681           if (i >= elf_header.e_shnum)
 682             continue; /* FIXME: Should we issue an error message ?  */
 683
 684           if (streq (SECTION_NAME (section_headers + i), name))
 685             return section_headers + i;
 686         }
 687     }
 688
 689   return find_section (name);
 690 }
 691
 692 /* Read an unsigned LEB128 encoded value from DATA.
 693    Set *LENGTH_RETURN to the number of bytes read.  */
 694
 695 static inline unsigned long
 696 read_uleb128 (unsigned char * data,
 697               unsigned int * length_return,
 698               const unsigned char * const end)
 699 {
 700   return read_leb128 (data, length_return, FALSE, end);
 701 }
 702
 703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 704    This OS has so many departures from the ELF standard that we test it at
 705    many places.  */
 706
 707 static inline bfd_boolean
 708 is_ia64_vms (void)
 709 {
 710   return elf_header.e_machine == EM_IA_64
 711     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 712 }
 713
 714 /* Guess the relocation size commonly used by the specific machines.  */
 715
 716 static bfd_boolean
 717 guess_is_rela (unsigned int e_machine)
 718 {
 719   switch (e_machine)
 720     {
 721       /* Targets that use REL relocations.  */
 722     case EM_386:
 723     case EM_IAMCU:
 724     case EM_960:
 725     case EM_ARM:
 726     case EM_D10V:
 727     case EM_CYGNUS_D10V:
 728     case EM_DLX:
 729     case EM_MIPS:
 730     case EM_MIPS_RS3_LE:
 731     case EM_CYGNUS_M32R:
 732     case EM_SCORE:
 733     case EM_XGATE:
 734       return FALSE;
 735
 736       /* Targets that use RELA relocations.  */
 737     case EM_68K:
 738     case EM_860:
 739     case EM_AARCH64:
 740     case EM_ADAPTEVA_EPIPHANY:
 741     case EM_ALPHA:
 742     case EM_ALTERA_NIOS2:
 743     case EM_ARC:
 744     case EM_ARC_COMPACT:
 745     case EM_ARC_COMPACT2:
 746     case EM_AVR:
 747     case EM_AVR_OLD:
 748     case EM_BLACKFIN:
 749     case EM_CR16:
 750     case EM_CRIS:
 751     case EM_CRX:
 752     case EM_D30V:
 753     case EM_CYGNUS_D30V:
 754     case EM_FR30:
 755     case EM_FT32:
 756     case EM_CYGNUS_FR30:
 757     case EM_CYGNUS_FRV:
 758     case EM_H8S:
 759     case EM_H8_300:
 760     case EM_H8_300H:
 761     case EM_IA_64:
 762     case EM_IP2K:
 763     case EM_IP2K_OLD:
 764     case EM_IQ2000:
 765     case EM_LATTICEMICO32:
 766     case EM_M32C_OLD:
 767     case EM_M32C:
 768     case EM_M32R:
 769     case EM_MCORE:
 770     case EM_CYGNUS_MEP:
 771     case EM_METAG:
 772     case EM_MMIX:
 773     case EM_MN10200:
 774     case EM_CYGNUS_MN10200:
 775     case EM_MN10300:
 776     case EM_CYGNUS_MN10300:
 777     case EM_MOXIE:
 778     case EM_MSP430:
 779     case EM_MSP430_OLD:
 780     case EM_MT:
 781     case EM_NDS32:
 782     case EM_NIOS32:
 783     case EM_OR1K:
 784     case EM_PPC64:
 785     case EM_PPC:
 786     case EM_TI_PRU:
 787     case EM_RISCV:
 788     case EM_RL78:
 789     case EM_RX:
 790     case EM_S390:
 791     case EM_S390_OLD:
 792     case EM_SH:
 793     case EM_SPARC:
 794     case EM_SPARC32PLUS:
 795     case EM_SPARCV9:
 796     case EM_SPU:
 797     case EM_TI_C6000:
 798     case EM_TILEGX:
 799     case EM_TILEPRO:
 800     case EM_V800:
 801     case EM_V850:
 802     case EM_CYGNUS_V850:
 803     case EM_VAX:
 804     case EM_VISIUM:
 805     case EM_X86_64:
 806     case EM_L1OM:
 807     case EM_K1OM:
 808     case EM_XSTORMY16:
 809     case EM_XTENSA:
 810     case EM_XTENSA_OLD:
 811     case EM_MICROBLAZE:
 812     case EM_MICROBLAZE_OLD:
 813     case EM_WEBASSEMBLY:
 814       return TRUE;
 815
 816     case EM_68HC05:
 817     case EM_68HC08:
 818     case EM_68HC11:
 819     case EM_68HC16:
 820     case EM_FX66:
 821     case EM_ME16:
 822     case EM_MMA:
 823     case EM_NCPU:
 824     case EM_NDR1:
 825     case EM_PCP:
 826     case EM_ST100:
 827     case EM_ST19:
 828     case EM_ST7:
 829     case EM_ST9PLUS:
 830     case EM_STARCORE:
 831     case EM_SVX:
 832     case EM_TINYJ:
 833     default:
 834       warn (_("Don't know about relocations on this machine architecture\n"));
 835       return FALSE;
 836     }
 837 }
 838
 839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 840    Returns TRUE upon success, FALSE otherwise.  If successful then a
 841    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 842    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 843    responsibility to free the allocated buffer.  */
 844
 845 static bfd_boolean
 846 slurp_rela_relocs (FILE * file,
 847                    unsigned long rel_offset,
 848                    unsigned long rel_size,
 849                    Elf_Internal_Rela ** relasp,
 850                    unsigned long * nrelasp)
 851 {
 852   Elf_Internal_Rela * relas;
 853   size_t nrelas;
 854   unsigned int i;
 855
 856   if (is_32bit_elf)
 857     {
 858       Elf32_External_Rela * erelas;
 859
 860       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 861                                                  rel_size, _("32-bit relocation data"));
 862       if (!erelas)
 863         return FALSE;
 864
 865       nrelas = rel_size / sizeof (Elf32_External_Rela);
 866
 867       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 868                                              sizeof (Elf_Internal_Rela));
 869
 870       if (relas == NULL)
 871         {
 872           free (erelas);
 873           error (_("out of memory parsing relocs\n"));
 874           return FALSE;
 875         }
 876
 877       for (i = 0; i < nrelas; i++)
 878         {
 879           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 880           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 881           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 882         }
 883
 884       free (erelas);
 885     }
 886   else
 887     {
 888       Elf64_External_Rela * erelas;
 889
 890       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 891                                                  rel_size, _("64-bit relocation data"));
 892       if (!erelas)
 893         return FALSE;
 894
 895       nrelas = rel_size / sizeof (Elf64_External_Rela);
 896
 897       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 898                                              sizeof (Elf_Internal_Rela));
 899
 900       if (relas == NULL)
 901         {
 902           free (erelas);
 903           error (_("out of memory parsing relocs\n"));
 904           return FALSE;
 905         }
 906
 907       for (i = 0; i < nrelas; i++)
 908         {
 909           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 910           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 911           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 912
 913           /* The #ifdef BFD64 below is to prevent a compile time
 914              warning.  We know that if we do not have a 64 bit data
 915              type that we will never execute this code anyway.  */
 916 #ifdef BFD64
 917           if (elf_header.e_machine == EM_MIPS
 918               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 919             {
 920               /* In little-endian objects, r_info isn't really a
 921                  64-bit little-endian value: it has a 32-bit
 922                  little-endian symbol index followed by four
 923                  individual byte fields.  Reorder INFO
 924                  accordingly.  */
 925               bfd_vma inf = relas[i].r_info;
 926               inf = (((inf & 0xffffffff) << 32)
 927                       | ((inf >> 56) & 0xff)
 928                       | ((inf >> 40) & 0xff00)
 929                       | ((inf >> 24) & 0xff0000)
 930                       | ((inf >> 8) & 0xff000000));
 931               relas[i].r_info = inf;
 932             }
 933 #endif /* BFD64 */
 934         }
 935
 936       free (erelas);
 937     }
 938
 939   *relasp = relas;
 940   *nrelasp = nrelas;
 941   return TRUE;
 942 }
 943
 944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 945    Returns TRUE upon success, FALSE otherwise.  If successful then a
 946    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 947    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 948    responsibility to free the allocated buffer.  */
 949
 950 static bfd_boolean
 951 slurp_rel_relocs (FILE * file,
 952                   unsigned long rel_offset,
 953                   unsigned long rel_size,
 954                   Elf_Internal_Rela ** relsp,
 955                   unsigned long * nrelsp)
 956 {
 957   Elf_Internal_Rela * rels;
 958   size_t nrels;
 959   unsigned int i;
 960
 961   if (is_32bit_elf)
 962     {
 963       Elf32_External_Rel * erels;
 964
 965       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 966                                                rel_size, _("32-bit relocation data"));
 967       if (!erels)
 968         return FALSE;
 969
 970       nrels = rel_size / sizeof (Elf32_External_Rel);
 971
 972       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 973
 974       if (rels == NULL)
 975         {
 976           free (erels);
 977           error (_("out of memory parsing relocs\n"));
 978           return FALSE;
 979         }
 980
 981       for (i = 0; i < nrels; i++)
 982         {
 983           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 984           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 985           rels[i].r_addend = 0;
 986         }
 987
 988       free (erels);
 989     }
 990   else
 991     {
 992       Elf64_External_Rel * erels;
 993
 994       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 995                                                rel_size, _("64-bit relocation data"));
 996       if (!erels)
 997         return FALSE;
 998
 999       nrels = rel_size / sizeof (Elf64_External_Rel);
1000
1001       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1002
1003       if (rels == NULL)
1004         {
1005           free (erels);
1006           error (_("out of memory parsing relocs\n"));
1007           return FALSE;
1008         }
1009
1010       for (i = 0; i < nrels; i++)
1011         {
1012           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1013           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1014           rels[i].r_addend = 0;
1015
1016           /* The #ifdef BFD64 below is to prevent a compile time
1017              warning.  We know that if we do not have a 64 bit data
1018              type that we will never execute this code anyway.  */
1019 #ifdef BFD64
1020           if (elf_header.e_machine == EM_MIPS
1021               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1022             {
1023               /* In little-endian objects, r_info isn't really a
1024                  64-bit little-endian value: it has a 32-bit
1025                  little-endian symbol index followed by four
1026                  individual byte fields.  Reorder INFO
1027                  accordingly.  */
1028               bfd_vma inf = rels[i].r_info;
1029               inf = (((inf & 0xffffffff) << 32)
1030                      | ((inf >> 56) & 0xff)
1031                      | ((inf >> 40) & 0xff00)
1032                      | ((inf >> 24) & 0xff0000)
1033                      | ((inf >> 8) & 0xff000000));
1034               rels[i].r_info = inf;
1035             }
1036 #endif /* BFD64 */
1037         }
1038
1039       free (erels);
1040     }
1041
1042   *relsp = rels;
1043   *nrelsp = nrels;
1044   return TRUE;
1045 }
1046
1047 /* Returns the reloc type extracted from the reloc info field.  */
1048
1049 static unsigned int
1050 get_reloc_type (bfd_vma reloc_info)
1051 {
1052   if (is_32bit_elf)
1053     return ELF32_R_TYPE (reloc_info);
1054
1055   switch (elf_header.e_machine)
1056     {
1057     case EM_MIPS:
1058       /* Note: We assume that reloc_info has already been adjusted for us.  */
1059       return ELF64_MIPS_R_TYPE (reloc_info);
1060
1061     case EM_SPARCV9:
1062       return ELF64_R_TYPE_ID (reloc_info);
1063
1064     default:
1065       return ELF64_R_TYPE (reloc_info);
1066     }
1067 }
1068
1069 /* Return the symbol index extracted from the reloc info field.  */
1070
1071 static bfd_vma
1072 get_reloc_symindex (bfd_vma reloc_info)
1073 {
1074   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1075 }
1076
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1079 {
1080   return
1081     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1082     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1083     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1084         /* TI compiler uses ELFOSABI_NONE.  */
1085         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1086 }
1087
1088 /* Display the contents of the relocation data found at the specified
1089    offset.  */
1090
1091 static bfd_boolean
1092 dump_relocations (FILE * file,
1093                   unsigned long rel_offset,
1094                   unsigned long rel_size,
1095                   Elf_Internal_Sym * symtab,
1096                   unsigned long nsyms,
1097                   char * strtab,
1098                   unsigned long strtablen,
1099                   int is_rela,
1100                   bfd_boolean is_dynsym)
1101 {
1102   unsigned long i;
1103   Elf_Internal_Rela * rels;
1104   bfd_boolean res = TRUE;
1105
1106   if (is_rela == UNKNOWN)
1107     is_rela = guess_is_rela (elf_header.e_machine);
1108
1109   if (is_rela)
1110     {
1111       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1112         return FALSE;
1113     }
1114   else
1115     {
1116       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1117         return FALSE;
1118     }
1119
1120   if (is_32bit_elf)
1121     {
1122       if (is_rela)
1123         {
1124           if (do_wide)
1125             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1126           else
1127             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1128         }
1129       else
1130         {
1131           if (do_wide)
1132             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1133           else
1134             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1135         }
1136     }
1137   else
1138     {
1139       if (is_rela)
1140         {
1141           if (do_wide)
1142             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1143           else
1144             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1145         }
1146       else
1147         {
1148           if (do_wide)
1149             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1150           else
1151             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1152         }
1153     }
1154
1155   for (i = 0; i < rel_size; i++)
1156     {
1157       const char * rtype;
1158       bfd_vma offset;
1159       bfd_vma inf;
1160       bfd_vma symtab_index;
1161       bfd_vma type;
1162
1163       offset = rels[i].r_offset;
1164       inf    = rels[i].r_info;
1165
1166       type = get_reloc_type (inf);
1167       symtab_index = get_reloc_symindex  (inf);
1168
1169       if (is_32bit_elf)
1170         {
1171           printf ("%8.8lx  %8.8lx ",
1172                   (unsigned long) offset & 0xffffffff,
1173                   (unsigned long) inf & 0xffffffff);
1174         }
1175       else
1176         {
1177 #if BFD_HOST_64BIT_LONG
1178           printf (do_wide
1179                   ? "%16.16lx  %16.16lx "
1180                   : "%12.12lx  %12.12lx ",
1181                   offset, inf);
1182 #elif BFD_HOST_64BIT_LONG_LONG
1183 #ifndef __MSVCRT__
1184           printf (do_wide
1185                   ? "%16.16llx  %16.16llx "
1186                   : "%12.12llx  %12.12llx ",
1187                   offset, inf);
1188 #else
1189           printf (do_wide
1190                   ? "%16.16I64x  %16.16I64x "
1191                   : "%12.12I64x  %12.12I64x ",
1192                   offset, inf);
1193 #endif
1194 #else
1195           printf (do_wide
1196                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1197                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1198                   _bfd_int64_high (offset),
1199                   _bfd_int64_low (offset),
1200                   _bfd_int64_high (inf),
1201                   _bfd_int64_low (inf));
1202 #endif
1203         }
1204
1205       switch (elf_header.e_machine)
1206         {
1207         default:
1208           rtype = NULL;
1209           break;
1210
1211         case EM_AARCH64:
1212           rtype = elf_aarch64_reloc_type (type);
1213           break;
1214
1215         case EM_M32R:
1216         case EM_CYGNUS_M32R:
1217           rtype = elf_m32r_reloc_type (type);
1218           break;
1219
1220         case EM_386:
1221         case EM_IAMCU:
1222           rtype = elf_i386_reloc_type (type);
1223           break;
1224
1225         case EM_68HC11:
1226         case EM_68HC12:
1227           rtype = elf_m68hc11_reloc_type (type);
1228           break;
1229
1230         case EM_68K:
1231           rtype = elf_m68k_reloc_type (type);
1232           break;
1233
1234         case EM_960:
1235           rtype = elf_i960_reloc_type (type);
1236           break;
1237
1238         case EM_AVR:
1239         case EM_AVR_OLD:
1240           rtype = elf_avr_reloc_type (type);
1241           break;
1242
1243         case EM_OLD_SPARCV9:
1244         case EM_SPARC32PLUS:
1245         case EM_SPARCV9:
1246         case EM_SPARC:
1247           rtype = elf_sparc_reloc_type (type);
1248           break;
1249
1250         case EM_SPU:
1251           rtype = elf_spu_reloc_type (type);
1252           break;
1253
1254         case EM_V800:
1255           rtype = v800_reloc_type (type);
1256           break;
1257         case EM_V850:
1258         case EM_CYGNUS_V850:
1259           rtype = v850_reloc_type (type);
1260           break;
1261
1262         case EM_D10V:
1263         case EM_CYGNUS_D10V:
1264           rtype = elf_d10v_reloc_type (type);
1265           break;
1266
1267         case EM_D30V:
1268         case EM_CYGNUS_D30V:
1269           rtype = elf_d30v_reloc_type (type);
1270           break;
1271
1272         case EM_DLX:
1273           rtype = elf_dlx_reloc_type (type);
1274           break;
1275
1276         case EM_SH:
1277           rtype = elf_sh_reloc_type (type);
1278           break;
1279
1280         case EM_MN10300:
1281         case EM_CYGNUS_MN10300:
1282           rtype = elf_mn10300_reloc_type (type);
1283           break;
1284
1285         case EM_MN10200:
1286         case EM_CYGNUS_MN10200:
1287           rtype = elf_mn10200_reloc_type (type);
1288           break;
1289
1290         case EM_FR30:
1291         case EM_CYGNUS_FR30:
1292           rtype = elf_fr30_reloc_type (type);
1293           break;
1294
1295         case EM_CYGNUS_FRV:
1296           rtype = elf_frv_reloc_type (type);
1297           break;
1298
1299         case EM_FT32:
1300           rtype = elf_ft32_reloc_type (type);
1301           break;
1302
1303         case EM_MCORE:
1304           rtype = elf_mcore_reloc_type (type);
1305           break;
1306
1307         case EM_MMIX:
1308           rtype = elf_mmix_reloc_type (type);
1309           break;
1310
1311         case EM_MOXIE:
1312           rtype = elf_moxie_reloc_type (type);
1313           break;
1314
1315         case EM_MSP430:
1316           if (uses_msp430x_relocs ())
1317             {
1318               rtype = elf_msp430x_reloc_type (type);
1319               break;
1320             }
1321           /* Fall through.  */
1322         case EM_MSP430_OLD:
1323           rtype = elf_msp430_reloc_type (type);
1324           break;
1325
1326         case EM_NDS32:
1327           rtype = elf_nds32_reloc_type (type);
1328           break;
1329
1330         case EM_PPC:
1331           rtype = elf_ppc_reloc_type (type);
1332           break;
1333
1334         case EM_PPC64:
1335           rtype = elf_ppc64_reloc_type (type);
1336           break;
1337
1338         case EM_MIPS:
1339         case EM_MIPS_RS3_LE:
1340           rtype = elf_mips_reloc_type (type);
1341           break;
1342
1343         case EM_RISCV:
1344           rtype = elf_riscv_reloc_type (type);
1345           break;
1346
1347         case EM_ALPHA:
1348           rtype = elf_alpha_reloc_type (type);
1349           break;
1350
1351         case EM_ARM:
1352           rtype = elf_arm_reloc_type (type);
1353           break;
1354
1355         case EM_ARC:
1356         case EM_ARC_COMPACT:
1357         case EM_ARC_COMPACT2:
1358           rtype = elf_arc_reloc_type (type);
1359           break;
1360
1361         case EM_PARISC:
1362           rtype = elf_hppa_reloc_type (type);
1363           break;
1364
1365         case EM_H8_300:
1366         case EM_H8_300H:
1367         case EM_H8S:
1368           rtype = elf_h8_reloc_type (type);
1369           break;
1370
1371         case EM_OR1K:
1372           rtype = elf_or1k_reloc_type (type);
1373           break;
1374
1375         case EM_PJ:
1376         case EM_PJ_OLD:
1377           rtype = elf_pj_reloc_type (type);
1378           break;
1379         case EM_IA_64:
1380           rtype = elf_ia64_reloc_type (type);
1381           break;
1382
1383         case EM_CRIS:
1384           rtype = elf_cris_reloc_type (type);
1385           break;
1386
1387         case EM_860:
1388           rtype = elf_i860_reloc_type (type);
1389           break;
1390
1391         case EM_X86_64:
1392         case EM_L1OM:
1393         case EM_K1OM:
1394           rtype = elf_x86_64_reloc_type (type);
1395           break;
1396
1397         case EM_S370:
1398           rtype = i370_reloc_type (type);
1399           break;
1400
1401         case EM_S390_OLD:
1402         case EM_S390:
1403           rtype = elf_s390_reloc_type (type);
1404           break;
1405
1406         case EM_SCORE:
1407           rtype = elf_score_reloc_type (type);
1408           break;
1409
1410         case EM_XSTORMY16:
1411           rtype = elf_xstormy16_reloc_type (type);
1412           break;
1413
1414         case EM_CRX:
1415           rtype = elf_crx_reloc_type (type);
1416           break;
1417
1418         case EM_VAX:
1419           rtype = elf_vax_reloc_type (type);
1420           break;
1421
1422         case EM_VISIUM:
1423           rtype = elf_visium_reloc_type (type);
1424           break;
1425
1426         case EM_ADAPTEVA_EPIPHANY:
1427           rtype = elf_epiphany_reloc_type (type);
1428           break;
1429
1430         case EM_IP2K:
1431         case EM_IP2K_OLD:
1432           rtype = elf_ip2k_reloc_type (type);
1433           break;
1434
1435         case EM_IQ2000:
1436           rtype = elf_iq2000_reloc_type (type);
1437           break;
1438
1439         case EM_XTENSA_OLD:
1440         case EM_XTENSA:
1441           rtype = elf_xtensa_reloc_type (type);
1442           break;
1443
1444         case EM_LATTICEMICO32:
1445           rtype = elf_lm32_reloc_type (type);
1446           break;
1447
1448         case EM_M32C_OLD:
1449         case EM_M32C:
1450           rtype = elf_m32c_reloc_type (type);
1451           break;
1452
1453         case EM_MT:
1454           rtype = elf_mt_reloc_type (type);
1455           break;
1456
1457         case EM_BLACKFIN:
1458           rtype = elf_bfin_reloc_type (type);
1459           break;
1460
1461         case EM_CYGNUS_MEP:
1462           rtype = elf_mep_reloc_type (type);
1463           break;
1464
1465         case EM_CR16:
1466           rtype = elf_cr16_reloc_type (type);
1467           break;
1468
1469         case EM_MICROBLAZE:
1470         case EM_MICROBLAZE_OLD:
1471           rtype = elf_microblaze_reloc_type (type);
1472           break;
1473
1474         case EM_RL78:
1475           rtype = elf_rl78_reloc_type (type);
1476           break;
1477
1478         case EM_RX:
1479           rtype = elf_rx_reloc_type (type);
1480           break;
1481
1482         case EM_METAG:
1483           rtype = elf_metag_reloc_type (type);
1484           break;
1485
1486         case EM_XC16X:
1487         case EM_C166:
1488           rtype = elf_xc16x_reloc_type (type);
1489           break;
1490
1491         case EM_TI_C6000:
1492           rtype = elf_tic6x_reloc_type (type);
1493           break;
1494
1495         case EM_TILEGX:
1496           rtype = elf_tilegx_reloc_type (type);
1497           break;
1498
1499         case EM_TILEPRO:
1500           rtype = elf_tilepro_reloc_type (type);
1501           break;
1502
1503         case EM_WEBASSEMBLY:
1504           rtype = elf_wasm32_reloc_type (type);
1505           break;
1506
1507         case EM_XGATE:
1508           rtype = elf_xgate_reloc_type (type);
1509           break;
1510
1511         case EM_ALTERA_NIOS2:
1512           rtype = elf_nios2_reloc_type (type);
1513           break;
1514
1515         case EM_TI_PRU:
1516           rtype = elf_pru_reloc_type (type);
1517           break;
1518         }
1519
1520       if (rtype == NULL)
1521         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1522       else
1523         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1524
1525       if (elf_header.e_machine == EM_ALPHA
1526           && rtype != NULL
1527           && streq (rtype, "R_ALPHA_LITUSE")
1528           && is_rela)
1529         {
1530           switch (rels[i].r_addend)
1531             {
1532             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1533             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1534             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1535             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1536             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1537             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1538             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1539             default: rtype = NULL;
1540             }
1541
1542           if (rtype)
1543             printf (" (%s)", rtype);
1544           else
1545             {
1546               putchar (' ');
1547               printf (_("<unknown addend: %lx>"),
1548                       (unsigned long) rels[i].r_addend);
1549               res = FALSE;
1550             }
1551         }
1552       else if (symtab_index)
1553         {
1554           if (symtab == NULL || symtab_index >= nsyms)
1555             {
1556               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1557               res = FALSE;
1558             }
1559           else
1560             {
1561               Elf_Internal_Sym * psym;
1562               const char * version_string;
1563               enum versioned_symbol_info sym_info;
1564               unsigned short vna_other;
1565
1566               psym = symtab + symtab_index;
1567
1568               version_string
1569                 = get_symbol_version_string (file, is_dynsym,
1570                                              strtab, strtablen,
1571                                              symtab_index,
1572                                              psym,
1573                                              &sym_info,
1574                                              &vna_other);
1575
1576               printf (" ");
1577
1578               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1579                 {
1580                   const char * name;
1581                   unsigned int len;
1582                   unsigned int width = is_32bit_elf ? 8 : 14;
1583
1584                   /* Relocations against GNU_IFUNC symbols do not use the value
1585                      of the symbol as the address to relocate against.  Instead
1586                      they invoke the function named by the symbol and use its
1587                      result as the address for relocation.
1588
1589                      To indicate this to the user, do not display the value of
1590                      the symbol in the "Symbols's Value" field.  Instead show
1591                      its name followed by () as a hint that the symbol is
1592                      invoked.  */
1593
1594                   if (strtab == NULL
1595                       || psym->st_name == 0
1596                       || psym->st_name >= strtablen)
1597                     name = "??";
1598                   else
1599                     name = strtab + psym->st_name;
1600
1601                   len = print_symbol (width, name);
1602                   if (version_string)
1603                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1604                             version_string);
1605                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1606                 }
1607               else
1608                 {
1609                   print_vma (psym->st_value, LONG_HEX);
1610
1611                   printf (is_32bit_elf ? "   " : " ");
1612                 }
1613
1614               if (psym->st_name == 0)
1615                 {
1616                   const char * sec_name = "<null>";
1617                   char name_buf[40];
1618
1619                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1620                     {
1621                       if (psym->st_shndx < elf_header.e_shnum)
1622                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1623                       else if (psym->st_shndx == SHN_ABS)
1624                         sec_name = "ABS";
1625                       else if (psym->st_shndx == SHN_COMMON)
1626                         sec_name = "COMMON";
1627                       else if ((elf_header.e_machine == EM_MIPS
1628                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1629                                || (elf_header.e_machine == EM_TI_C6000
1630                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1631                         sec_name = "SCOMMON";
1632                       else if (elf_header.e_machine == EM_MIPS
1633                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1634                         sec_name = "SUNDEF";
1635                       else if ((elf_header.e_machine == EM_X86_64
1636                                 || elf_header.e_machine == EM_L1OM
1637                                 || elf_header.e_machine == EM_K1OM)
1638                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1639                         sec_name = "LARGE_COMMON";
1640                       else if (elf_header.e_machine == EM_IA_64
1641                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1642                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1643                         sec_name = "ANSI_COM";
1644                       else if (is_ia64_vms ()
1645                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1646                         sec_name = "VMS_SYMVEC";
1647                       else
1648                         {
1649                           sprintf (name_buf, "<section 0x%x>",
1650                                    (unsigned int) psym->st_shndx);
1651                           sec_name = name_buf;
1652                         }
1653                     }
1654                   print_symbol (22, sec_name);
1655                 }
1656               else if (strtab == NULL)
1657                 printf (_("<string table index: %3ld>"), psym->st_name);
1658               else if (psym->st_name >= strtablen)
1659                 {
1660                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1661                   res = FALSE;
1662                 }
1663               else
1664                 {
1665                   print_symbol (22, strtab + psym->st_name);
1666                   if (version_string)
1667                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1668                             version_string);
1669                 }
1670
1671               if (is_rela)
1672                 {
1673                   bfd_vma off = rels[i].r_addend;
1674
1675                   if ((bfd_signed_vma) off < 0)
1676                     printf (" - %" BFD_VMA_FMT "x", - off);
1677                   else
1678                     printf (" + %" BFD_VMA_FMT "x", off);
1679                 }
1680             }
1681         }
1682       else if (is_rela)
1683         {
1684           bfd_vma off = rels[i].r_addend;
1685
1686           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1687           if ((bfd_signed_vma) off < 0)
1688             printf ("-%" BFD_VMA_FMT "x", - off);
1689           else
1690             printf ("%" BFD_VMA_FMT "x", off);
1691         }
1692
1693       if (elf_header.e_machine == EM_SPARCV9
1694           && rtype != NULL
1695           && streq (rtype, "R_SPARC_OLO10"))
1696         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1697
1698       putchar ('\n');
1699
1700 #ifdef BFD64
1701       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1702         {
1703           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1704           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1705           const char * rtype2 = elf_mips_reloc_type (type2);
1706           const char * rtype3 = elf_mips_reloc_type (type3);
1707
1708           printf ("                    Type2: ");
1709
1710           if (rtype2 == NULL)
1711             printf (_("unrecognized: %-7lx"),
1712                     (unsigned long) type2 & 0xffffffff);
1713           else
1714             printf ("%-17.17s", rtype2);
1715
1716           printf ("\n                    Type3: ");
1717
1718           if (rtype3 == NULL)
1719             printf (_("unrecognized: %-7lx"),
1720                     (unsigned long) type3 & 0xffffffff);
1721           else
1722             printf ("%-17.17s", rtype3);
1723
1724           putchar ('\n');
1725         }
1726 #endif /* BFD64 */
1727     }
1728
1729   free (rels);
1730
1731   return res;
1732 }
1733
1734 static const char *
1735 get_mips_dynamic_type (unsigned long type)
1736 {
1737   switch (type)
1738     {
1739     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1740     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1741     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1742     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1743     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1744     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1745     case DT_MIPS_MSYM: return "MIPS_MSYM";
1746     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1747     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1748     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1749     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1750     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1751     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1752     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1753     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1754     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1755     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1756     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1757     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1758     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1759     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1760     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1761     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1762     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1763     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1764     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1765     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1766     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1767     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1768     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1769     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1770     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1771     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1772     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1773     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1774     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1775     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1776     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1777     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1778     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1780     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1781     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1782     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1783     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1784     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1785     default:
1786       return NULL;
1787     }
1788 }
1789
1790 static const char *
1791 get_sparc64_dynamic_type (unsigned long type)
1792 {
1793   switch (type)
1794     {
1795     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1796     default:
1797       return NULL;
1798     }
1799 }
1800
1801 static const char *
1802 get_ppc_dynamic_type (unsigned long type)
1803 {
1804   switch (type)
1805     {
1806     case DT_PPC_GOT:    return "PPC_GOT";
1807     case DT_PPC_OPT:    return "PPC_OPT";
1808     default:
1809       return NULL;
1810     }
1811 }
1812
1813 static const char *
1814 get_ppc64_dynamic_type (unsigned long type)
1815 {
1816   switch (type)
1817     {
1818     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1819     case DT_PPC64_OPD:    return "PPC64_OPD";
1820     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1821     case DT_PPC64_OPT:    return "PPC64_OPT";
1822     default:
1823       return NULL;
1824     }
1825 }
1826
1827 static const char *
1828 get_parisc_dynamic_type (unsigned long type)
1829 {
1830   switch (type)
1831     {
1832     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1833     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1834     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1835     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1836     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1837     case DT_HP_PREINIT:         return "HP_PREINIT";
1838     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1839     case DT_HP_NEEDED:          return "HP_NEEDED";
1840     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1841     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1842     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1843     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1844     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1845     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1846     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1847     case DT_HP_FILTERED:        return "HP_FILTERED";
1848     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1849     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1850     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1851     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1852     case DT_PLT:                return "PLT";
1853     case DT_PLT_SIZE:           return "PLT_SIZE";
1854     case DT_DLT:                return "DLT";
1855     case DT_DLT_SIZE:           return "DLT_SIZE";
1856     default:
1857       return NULL;
1858     }
1859 }
1860
1861 static const char *
1862 get_ia64_dynamic_type (unsigned long type)
1863 {
1864   switch (type)
1865     {
1866     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1867     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1868     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1869     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1870     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1871     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1872     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1873     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1874     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1875     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1876     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1877     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1878     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1879     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1880     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1881     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1882     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1883     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1884     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1885     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1886     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1887     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1888     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1889     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1890     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1891     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1892     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1893     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1894     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1895     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1896     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1897     default:
1898       return NULL;
1899     }
1900 }
1901
1902 static const char *
1903 get_solaris_section_type (unsigned long type)
1904 {
1905   switch (type)
1906     {
1907     case 0x6fffffee: return "SUNW_ancillary";
1908     case 0x6fffffef: return "SUNW_capchain";
1909     case 0x6ffffff0: return "SUNW_capinfo";
1910     case 0x6ffffff1: return "SUNW_symsort";
1911     case 0x6ffffff2: return "SUNW_tlssort";
1912     case 0x6ffffff3: return "SUNW_LDYNSYM";
1913     case 0x6ffffff4: return "SUNW_dof";
1914     case 0x6ffffff5: return "SUNW_cap";
1915     case 0x6ffffff6: return "SUNW_SIGNATURE";
1916     case 0x6ffffff7: return "SUNW_ANNOTATE";
1917     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918     case 0x6ffffff9: return "SUNW_DEBUG";
1919     case 0x6ffffffa: return "SUNW_move";
1920     case 0x6ffffffb: return "SUNW_COMDAT";
1921     case 0x6ffffffc: return "SUNW_syminfo";
1922     case 0x6ffffffd: return "SUNW_verdef";
1923     case 0x6ffffffe: return "SUNW_verneed";
1924     case 0x6fffffff: return "SUNW_versym";
1925     case 0x70000000: return "SPARC_GOTDATA";
1926     default: return NULL;
1927     }
1928 }
1929
1930 static const char *
1931 get_alpha_dynamic_type (unsigned long type)
1932 {
1933   switch (type)
1934     {
1935     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1936     default: return NULL;
1937     }
1938 }
1939
1940 static const char *
1941 get_score_dynamic_type (unsigned long type)
1942 {
1943   switch (type)
1944     {
1945     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1946     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1947     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1948     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1949     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1950     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1951     default:                    return NULL;
1952     }
1953 }
1954
1955 static const char *
1956 get_tic6x_dynamic_type (unsigned long type)
1957 {
1958   switch (type)
1959     {
1960     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1961     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1962     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1963     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1964     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1965     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1966     default:                   return NULL;
1967     }
1968 }
1969
1970 static const char *
1971 get_nios2_dynamic_type (unsigned long type)
1972 {
1973   switch (type)
1974     {
1975     case DT_NIOS2_GP: return "NIOS2_GP";
1976     default:          return NULL;
1977     }
1978 }
1979
1980 static const char *
1981 get_solaris_dynamic_type (unsigned long type)
1982 {
1983   switch (type)
1984     {
1985     case 0x6000000d: return "SUNW_AUXILIARY";
1986     case 0x6000000e: return "SUNW_RTLDINF";
1987     case 0x6000000f: return "SUNW_FILTER";
1988     case 0x60000010: return "SUNW_CAP";
1989     case 0x60000011: return "SUNW_SYMTAB";
1990     case 0x60000012: return "SUNW_SYMSZ";
1991     case 0x60000013: return "SUNW_SORTENT";
1992     case 0x60000014: return "SUNW_SYMSORT";
1993     case 0x60000015: return "SUNW_SYMSORTSZ";
1994     case 0x60000016: return "SUNW_TLSSORT";
1995     case 0x60000017: return "SUNW_TLSSORTSZ";
1996     case 0x60000018: return "SUNW_CAPINFO";
1997     case 0x60000019: return "SUNW_STRPAD";
1998     case 0x6000001a: return "SUNW_CAPCHAIN";
1999     case 0x6000001b: return "SUNW_LDMACH";
2000     case 0x6000001d: return "SUNW_CAPCHAINENT";
2001     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002     case 0x60000021: return "SUNW_PARENT";
2003     case 0x60000023: return "SUNW_ASLR";
2004     case 0x60000025: return "SUNW_RELAX";
2005     case 0x60000029: return "SUNW_NXHEAP";
2006     case 0x6000002b: return "SUNW_NXSTACK";
2007
2008     case 0x70000001: return "SPARC_REGISTER";
2009     case 0x7ffffffd: return "AUXILIARY";
2010     case 0x7ffffffe: return "USED";
2011     case 0x7fffffff: return "FILTER";
2012
2013     default: return NULL;
2014     }
2015 }
2016
2017 static const char *
2018 get_dynamic_type (unsigned long type)
2019 {
2020   static char buff[64];
2021
2022   switch (type)
2023     {
2024     case DT_NULL:       return "NULL";
2025     case DT_NEEDED:     return "NEEDED";
2026     case DT_PLTRELSZ:   return "PLTRELSZ";
2027     case DT_PLTGOT:     return "PLTGOT";
2028     case DT_HASH:       return "HASH";
2029     case DT_STRTAB:     return "STRTAB";
2030     case DT_SYMTAB:     return "SYMTAB";
2031     case DT_RELA:       return "RELA";
2032     case DT_RELASZ:     return "RELASZ";
2033     case DT_RELAENT:    return "RELAENT";
2034     case DT_STRSZ:      return "STRSZ";
2035     case DT_SYMENT:     return "SYMENT";
2036     case DT_INIT:       return "INIT";
2037     case DT_FINI:       return "FINI";
2038     case DT_SONAME:     return "SONAME";
2039     case DT_RPATH:      return "RPATH";
2040     case DT_SYMBOLIC:   return "SYMBOLIC";
2041     case DT_REL:        return "REL";
2042     case DT_RELSZ:      return "RELSZ";
2043     case DT_RELENT:     return "RELENT";
2044     case DT_PLTREL:     return "PLTREL";
2045     case DT_DEBUG:      return "DEBUG";
2046     case DT_TEXTREL:    return "TEXTREL";
2047     case DT_JMPREL:     return "JMPREL";
2048     case DT_BIND_NOW:   return "BIND_NOW";
2049     case DT_INIT_ARRAY: return "INIT_ARRAY";
2050     case DT_FINI_ARRAY: return "FINI_ARRAY";
2051     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2052     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2053     case DT_RUNPATH:    return "RUNPATH";
2054     case DT_FLAGS:      return "FLAGS";
2055
2056     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2057     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2058     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2059
2060     case DT_CHECKSUM:   return "CHECKSUM";
2061     case DT_PLTPADSZ:   return "PLTPADSZ";
2062     case DT_MOVEENT:    return "MOVEENT";
2063     case DT_MOVESZ:     return "MOVESZ";
2064     case DT_FEATURE:    return "FEATURE";
2065     case DT_POSFLAG_1:  return "POSFLAG_1";
2066     case DT_SYMINSZ:    return "SYMINSZ";
2067     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2068
2069     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2070     case DT_CONFIG:     return "CONFIG";
2071     case DT_DEPAUDIT:   return "DEPAUDIT";
2072     case DT_AUDIT:      return "AUDIT";
2073     case DT_PLTPAD:     return "PLTPAD";
2074     case DT_MOVETAB:    return "MOVETAB";
2075     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2076
2077     case DT_VERSYM:     return "VERSYM";
2078
2079     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2080     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2081     case DT_RELACOUNT:  return "RELACOUNT";
2082     case DT_RELCOUNT:   return "RELCOUNT";
2083     case DT_FLAGS_1:    return "FLAGS_1";
2084     case DT_VERDEF:     return "VERDEF";
2085     case DT_VERDEFNUM:  return "VERDEFNUM";
2086     case DT_VERNEED:    return "VERNEED";
2087     case DT_VERNEEDNUM: return "VERNEEDNUM";
2088
2089     case DT_AUXILIARY:  return "AUXILIARY";
2090     case DT_USED:       return "USED";
2091     case DT_FILTER:     return "FILTER";
2092
2093     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2094     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2095     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2096     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2097     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2098     case DT_GNU_HASH:   return "GNU_HASH";
2099
2100     default:
2101       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2102         {
2103           const char * result;
2104
2105           switch (elf_header.e_machine)
2106             {
2107             case EM_MIPS:
2108             case EM_MIPS_RS3_LE:
2109               result = get_mips_dynamic_type (type);
2110               break;
2111             case EM_SPARCV9:
2112               result = get_sparc64_dynamic_type (type);
2113               break;
2114             case EM_PPC:
2115               result = get_ppc_dynamic_type (type);
2116               break;
2117             case EM_PPC64:
2118               result = get_ppc64_dynamic_type (type);
2119               break;
2120             case EM_IA_64:
2121               result = get_ia64_dynamic_type (type);
2122               break;
2123             case EM_ALPHA:
2124               result = get_alpha_dynamic_type (type);
2125               break;
2126             case EM_SCORE:
2127               result = get_score_dynamic_type (type);
2128               break;
2129             case EM_TI_C6000:
2130               result = get_tic6x_dynamic_type (type);
2131               break;
2132             case EM_ALTERA_NIOS2:
2133               result = get_nios2_dynamic_type (type);
2134               break;
2135             default:
2136               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2137                 result = get_solaris_dynamic_type (type);
2138               else
2139                 result = NULL;
2140               break;
2141             }
2142
2143           if (result != NULL)
2144             return result;
2145
2146           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2147         }
2148       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2149                || (elf_header.e_machine == EM_PARISC
2150                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2151         {
2152           const char * result;
2153
2154           switch (elf_header.e_machine)
2155             {
2156             case EM_PARISC:
2157               result = get_parisc_dynamic_type (type);
2158               break;
2159             case EM_IA_64:
2160               result = get_ia64_dynamic_type (type);
2161               break;
2162             default:
2163               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2164                 result = get_solaris_dynamic_type (type);
2165               else
2166                 result = NULL;
2167               break;
2168             }
2169
2170           if (result != NULL)
2171             return result;
2172
2173           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2174                     type);
2175         }
2176       else
2177         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2178
2179       return buff;
2180     }
2181 }
2182
2183 static char *
2184 get_file_type (unsigned e_type)
2185 {
2186   static char buff[32];
2187
2188   switch (e_type)
2189     {
2190     case ET_NONE: return _("NONE (None)");
2191     case ET_REL:  return _("REL (Relocatable file)");
2192     case ET_EXEC: return _("EXEC (Executable file)");
2193     case ET_DYN:  return _("DYN (Shared object file)");
2194     case ET_CORE: return _("CORE (Core file)");
2195
2196     default:
2197       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2198         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2199       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2200         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2201       else
2202         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2203       return buff;
2204     }
2205 }
2206
2207 static char *
2208 get_machine_name (unsigned e_machine)
2209 {
2210   static char buff[64]; /* XXX */
2211
2212   switch (e_machine)
2213     {
2214       /* Please keep this switch table sorted by increasing EM_ value.  */
2215       /* 0 */
2216     case EM_NONE:               return _("None");
2217     case EM_M32:                return "WE32100";
2218     case EM_SPARC:              return "Sparc";
2219     case EM_386:                return "Intel 80386";
2220     case EM_68K:                return "MC68000";
2221     case EM_88K:                return "MC88000";
2222     case EM_IAMCU:              return "Intel MCU";
2223     case EM_860:                return "Intel 80860";
2224     case EM_MIPS:               return "MIPS R3000";
2225     case EM_S370:               return "IBM System/370";
2226       /* 10 */
2227     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2228     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2229     case EM_PARISC:             return "HPPA";
2230     case EM_VPP550:             return "Fujitsu VPP500";
2231     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2232     case EM_960:                return "Intel 90860";
2233     case EM_PPC:                return "PowerPC";
2234       /* 20 */
2235     case EM_PPC64:              return "PowerPC64";
2236     case EM_S390_OLD:
2237     case EM_S390:               return "IBM S/390";
2238     case EM_SPU:                return "SPU";
2239       /* 30 */
2240     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2241     case EM_FR20:               return "Fujitsu FR20";
2242     case EM_RH32:               return "TRW RH32";
2243     case EM_MCORE:              return "MCORE";
2244       /* 40 */
2245     case EM_ARM:                return "ARM";
2246     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2247     case EM_SH:                 return "Renesas / SuperH SH";
2248     case EM_SPARCV9:            return "Sparc v9";
2249     case EM_TRICORE:            return "Siemens Tricore";
2250     case EM_ARC:                return "ARC";
2251     case EM_H8_300:             return "Renesas H8/300";
2252     case EM_H8_300H:            return "Renesas H8/300H";
2253     case EM_H8S:                return "Renesas H8S";
2254     case EM_H8_500:             return "Renesas H8/500";
2255       /* 50 */
2256     case EM_IA_64:              return "Intel IA-64";
2257     case EM_MIPS_X:             return "Stanford MIPS-X";
2258     case EM_COLDFIRE:           return "Motorola Coldfire";
2259     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2260     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2261     case EM_PCP:                return "Siemens PCP";
2262     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2263     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2264     case EM_STARCORE:           return "Motorola Star*Core processor";
2265     case EM_ME16:               return "Toyota ME16 processor";
2266       /* 60 */
2267     case EM_ST100:              return "STMicroelectronics ST100 processor";
2268     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2269     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2270     case EM_PDSP:               return "Sony DSP processor";
2271     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2272     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2273     case EM_FX66:               return "Siemens FX66 microcontroller";
2274     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2276     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2277       /* 70 */
2278     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2279     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2280     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2281     case EM_SVX:                return "Silicon Graphics SVx";
2282     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2283     case EM_VAX:                return "Digital VAX";
2284     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2285     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2286     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2287     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2288       /* 80 */
2289     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2290     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2291     case EM_PRISM:              return "Vitesse Prism";
2292     case EM_AVR_OLD:
2293     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2294     case EM_CYGNUS_FR30:
2295     case EM_FR30:               return "Fujitsu FR30";
2296     case EM_CYGNUS_D10V:
2297     case EM_D10V:               return "d10v";
2298     case EM_CYGNUS_D30V:
2299     case EM_D30V:               return "d30v";
2300     case EM_CYGNUS_V850:
2301     case EM_V850:               return "Renesas V850";
2302     case EM_CYGNUS_M32R:
2303     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2304     case EM_CYGNUS_MN10300:
2305     case EM_MN10300:            return "mn10300";
2306       /* 90 */
2307     case EM_CYGNUS_MN10200:
2308     case EM_MN10200:            return "mn10200";
2309     case EM_PJ:                 return "picoJava";
2310     case EM_OR1K:               return "OpenRISC 1000";
2311     case EM_ARC_COMPACT:        return "ARCompact";
2312     case EM_XTENSA_OLD:
2313     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2314     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2315     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2316     case EM_NS32K:              return "National Semiconductor 32000 series";
2317     case EM_TPC:                return "Tenor Network TPC processor";
2318     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2319       /* 100 */
2320     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2321     case EM_IP2K_OLD:
2322     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2323     case EM_MAX:                return "MAX Processor";
2324     case EM_CR:                 return "National Semiconductor CompactRISC";
2325     case EM_F2MC16:             return "Fujitsu F2MC16";
2326     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2327     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2328     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2329     case EM_SEP:                return "Sharp embedded microprocessor";
2330     case EM_ARCA:               return "Arca RISC microprocessor";
2331       /* 110 */
2332     case EM_UNICORE:            return "Unicore";
2333     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2334     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2335     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2336     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2337     case EM_XGATE:              return "Motorola XGATE embedded processor";
2338     case EM_C166:
2339     case EM_XC16X:              return "Infineon Technologies xc16x";
2340     case EM_M16C:               return "Renesas M16C series microprocessors";
2341     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2342     case EM_CE:                 return "Freescale Communication Engine RISC core";
2343       /* 120 */
2344     case EM_M32C:               return "Renesas M32c";
2345       /* 130 */
2346     case EM_TSK3000:            return "Altium TSK3000 core";
2347     case EM_RS08:               return "Freescale RS08 embedded processor";
2348     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2349     case EM_SCORE:              return "SUNPLUS S+Core";
2350     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2351     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2352     case EM_LATTICEMICO32:      return "Lattice Mico32";
2353     case EM_SE_C17:             return "Seiko Epson C17 family";
2354       /* 140 */
2355     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2356     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2357     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2358     case EM_TI_PRU:             return "TI PRU I/O processor";
2359       /* 160 */
2360     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2362     case EM_R32C:               return "Renesas R32C series microprocessors";
2363     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2364     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2365     case EM_8051:               return "Intel 8051 and variants";
2366     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2367     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2368     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2369     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2370       /* 170 */
2371     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2372     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2373     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2374     case EM_RX:                 return "Renesas RX";
2375     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2376     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2377     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2378     case EM_CR16:
2379     case EM_MICROBLAZE:
2380     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2381     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2382     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2383       /* 180 */
2384     case EM_L1OM:               return "Intel L1OM";
2385     case EM_K1OM:               return "Intel K1OM";
2386     case EM_INTEL182:           return "Intel (reserved)";
2387     case EM_AARCH64:            return "AArch64";
2388     case EM_ARM184:             return "ARM (reserved)";
2389     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2390     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2391     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2392     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2393       /* 190 */
2394     case EM_CUDA:               return "NVIDIA CUDA architecture";
2395     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2396     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2397     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2398     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2399     case EM_ARC_COMPACT2:       return "ARCv2";
2400     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2401     case EM_RL78:               return "Renesas RL78";
2402     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2403     case EM_78K0R:              return "Renesas 78K0R";
2404       /* 200 */
2405     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2406     case EM_BA1:                return "Beyond BA1 CPU architecture";
2407     case EM_BA2:                return "Beyond BA2 CPU architecture";
2408     case EM_XCORE:              return "XMOS xCORE processor family";
2409     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2410       /* 210 */
2411     case EM_KM32:               return "KM211 KM32 32-bit processor";
2412     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2413     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2414     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2415     case EM_KVARC:              return "KM211 KVARC processor";
2416     case EM_CDP:                return "Paneve CDP architecture family";
2417     case EM_COGE:               return "Cognitive Smart Memory Processor";
2418     case EM_COOL:               return "Bluechip Systems CoolEngine";
2419     case EM_NORC:               return "Nanoradio Optimized RISC";
2420     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2421       /* 220 */
2422     case EM_Z80:                return "Zilog Z80";
2423     case EM_VISIUM:             return "CDS VISIUMcore processor";
2424     case EM_FT32:               return "FTDI Chip FT32";
2425     case EM_MOXIE:              return "Moxie";
2426     case EM_AMDGPU:             return "AMD GPU";
2427     case EM_RISCV:              return "RISC-V";
2428     case EM_LANAI:              return "Lanai 32-bit processor";
2429     case EM_BPF:                return "Linux BPF";
2430
2431       /* Large numbers...  */
2432     case EM_MT:                 return "Morpho Techologies MT processor";
2433     case EM_ALPHA:              return "Alpha";
2434     case EM_WEBASSEMBLY:        return "Web Assembly";
2435     case EM_DLX:                return "OpenDLX";
2436     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2437     case EM_IQ2000:             return "Vitesse IQ2000";
2438     case EM_M32C_OLD:
2439     case EM_NIOS32:             return "Altera Nios";
2440     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2441     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2442     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2443
2444     default:
2445       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2446       return buff;
2447     }
2448 }
2449
2450 static void
2451 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2452 {
2453   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2454      other compilers don't a specific architecture type in the e_flags, and
2455      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2457      architectures.
2458
2459      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460      but also sets a specific architecture type in the e_flags field.
2461
2462      However, when decoding the flags we don't worry if we see an
2463      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464      ARCEM architecture type.  */
2465
2466   switch (e_flags & EF_ARC_MACH_MSK)
2467     {
2468       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2469     case EF_ARC_CPU_ARCV2EM:
2470       strcat (buf, ", ARC EM");
2471       break;
2472     case EF_ARC_CPU_ARCV2HS:
2473       strcat (buf, ", ARC HS");
2474       break;
2475
2476       /* We only expect these to occur for EM_ARC_COMPACT.  */
2477     case E_ARC_MACH_ARC600:
2478       strcat (buf, ", ARC600");
2479       break;
2480     case E_ARC_MACH_ARC601:
2481       strcat (buf, ", ARC601");
2482       break;
2483     case E_ARC_MACH_ARC700:
2484       strcat (buf, ", ARC700");
2485       break;
2486
2487       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488          new ELF with new architecture being read by an old version of
2489          readelf, or (c) An ELF built with non-GNU compiler that does not
2490          set the architecture in the e_flags.  */
2491     default:
2492       if (e_machine == EM_ARC_COMPACT)
2493         strcat (buf, ", Unknown ARCompact");
2494       else
2495         strcat (buf, ", Unknown ARC");
2496       break;
2497     }
2498
2499   switch (e_flags & EF_ARC_OSABI_MSK)
2500     {
2501     case E_ARC_OSABI_ORIG:
2502       strcat (buf, ", (ABI:legacy)");
2503       break;
2504     case E_ARC_OSABI_V2:
2505       strcat (buf, ", (ABI:v2)");
2506       break;
2507       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2508     case E_ARC_OSABI_V3:
2509       strcat (buf, ", v3 no-legacy-syscalls ABI");
2510       break;
2511     case E_ARC_OSABI_V4:
2512       strcat (buf, ", v4 ABI");
2513       break;
2514     default:
2515       strcat (buf, ", unrecognised ARC OSABI flag");
2516       break;
2517     }
2518 }
2519
2520 static void
2521 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2522 {
2523   unsigned eabi;
2524   bfd_boolean unknown = FALSE;
2525
2526   eabi = EF_ARM_EABI_VERSION (e_flags);
2527   e_flags &= ~ EF_ARM_EABIMASK;
2528
2529   /* Handle "generic" ARM flags.  */
2530   if (e_flags & EF_ARM_RELEXEC)
2531     {
2532       strcat (buf, ", relocatable executable");
2533       e_flags &= ~ EF_ARM_RELEXEC;
2534     }
2535
2536   /* Now handle EABI specific flags.  */
2537   switch (eabi)
2538     {
2539     default:
2540       strcat (buf, ", <unrecognized EABI>");
2541       if (e_flags)
2542         unknown = TRUE;
2543       break;
2544
2545     case EF_ARM_EABI_VER1:
2546       strcat (buf, ", Version1 EABI");
2547       while (e_flags)
2548         {
2549           unsigned flag;
2550
2551           /* Process flags one bit at a time.  */
2552           flag = e_flags & - e_flags;
2553           e_flags &= ~ flag;
2554
2555           switch (flag)
2556             {
2557             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2558               strcat (buf, ", sorted symbol tables");
2559               break;
2560
2561             default:
2562               unknown = TRUE;
2563               break;
2564             }
2565         }
2566       break;
2567
2568     case EF_ARM_EABI_VER2:
2569       strcat (buf, ", Version2 EABI");
2570       while (e_flags)
2571         {
2572           unsigned flag;
2573
2574           /* Process flags one bit at a time.  */
2575           flag = e_flags & - e_flags;
2576           e_flags &= ~ flag;
2577
2578           switch (flag)
2579             {
2580             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2581               strcat (buf, ", sorted symbol tables");
2582               break;
2583
2584             case EF_ARM_DYNSYMSUSESEGIDX:
2585               strcat (buf, ", dynamic symbols use segment index");
2586               break;
2587
2588             case EF_ARM_MAPSYMSFIRST:
2589               strcat (buf, ", mapping symbols precede others");
2590               break;
2591
2592             default:
2593               unknown = TRUE;
2594               break;
2595             }
2596         }
2597       break;
2598
2599     case EF_ARM_EABI_VER3:
2600       strcat (buf, ", Version3 EABI");
2601       break;
2602
2603     case EF_ARM_EABI_VER4:
2604       strcat (buf, ", Version4 EABI");
2605       while (e_flags)
2606         {
2607           unsigned flag;
2608
2609           /* Process flags one bit at a time.  */
2610           flag = e_flags & - e_flags;
2611           e_flags &= ~ flag;
2612
2613           switch (flag)
2614             {
2615             case EF_ARM_BE8:
2616               strcat (buf, ", BE8");
2617               break;
2618
2619             case EF_ARM_LE8:
2620               strcat (buf, ", LE8");
2621               break;
2622
2623             default:
2624               unknown = TRUE;
2625               break;
2626             }
2627         }
2628       break;
2629
2630     case EF_ARM_EABI_VER5:
2631       strcat (buf, ", Version5 EABI");
2632       while (e_flags)
2633         {
2634           unsigned flag;
2635
2636           /* Process flags one bit at a time.  */
2637           flag = e_flags & - e_flags;
2638           e_flags &= ~ flag;
2639
2640           switch (flag)
2641             {
2642             case EF_ARM_BE8:
2643               strcat (buf, ", BE8");
2644               break;
2645
2646             case EF_ARM_LE8:
2647               strcat (buf, ", LE8");
2648               break;
2649
2650             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2651               strcat (buf, ", soft-float ABI");
2652               break;
2653
2654             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2655               strcat (buf, ", hard-float ABI");
2656               break;
2657
2658             default:
2659               unknown = TRUE;
2660               break;
2661             }
2662         }
2663       break;
2664
2665     case EF_ARM_EABI_UNKNOWN:
2666       strcat (buf, ", GNU EABI");
2667       while (e_flags)
2668         {
2669           unsigned flag;
2670
2671           /* Process flags one bit at a time.  */
2672           flag = e_flags & - e_flags;
2673           e_flags &= ~ flag;
2674
2675           switch (flag)
2676             {
2677             case EF_ARM_INTERWORK:
2678               strcat (buf, ", interworking enabled");
2679               break;
2680
2681             case EF_ARM_APCS_26:
2682               strcat (buf, ", uses APCS/26");
2683               break;
2684
2685             case EF_ARM_APCS_FLOAT:
2686               strcat (buf, ", uses APCS/float");
2687               break;
2688
2689             case EF_ARM_PIC:
2690               strcat (buf, ", position independent");
2691               break;
2692
2693             case EF_ARM_ALIGN8:
2694               strcat (buf, ", 8 bit structure alignment");
2695               break;
2696
2697             case EF_ARM_NEW_ABI:
2698               strcat (buf, ", uses new ABI");
2699               break;
2700
2701             case EF_ARM_OLD_ABI:
2702               strcat (buf, ", uses old ABI");
2703               break;
2704
2705             case EF_ARM_SOFT_FLOAT:
2706               strcat (buf, ", software FP");
2707               break;
2708
2709             case EF_ARM_VFP_FLOAT:
2710               strcat (buf, ", VFP");
2711               break;
2712
2713             case EF_ARM_MAVERICK_FLOAT:
2714               strcat (buf, ", Maverick FP");
2715               break;
2716
2717             default:
2718               unknown = TRUE;
2719               break;
2720             }
2721         }
2722     }
2723
2724   if (unknown)
2725     strcat (buf,_(", <unknown>"));
2726 }
2727
2728 static void
2729 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2730 {
2731   --size; /* Leave space for null terminator.  */
2732
2733   switch (e_flags & EF_AVR_MACH)
2734     {
2735     case E_AVR_MACH_AVR1:
2736       strncat (buf, ", avr:1", size);
2737       break;
2738     case E_AVR_MACH_AVR2:
2739       strncat (buf, ", avr:2", size);
2740       break;
2741     case E_AVR_MACH_AVR25:
2742       strncat (buf, ", avr:25", size);
2743       break;
2744     case E_AVR_MACH_AVR3:
2745       strncat (buf, ", avr:3", size);
2746       break;
2747     case E_AVR_MACH_AVR31:
2748       strncat (buf, ", avr:31", size);
2749       break;
2750     case E_AVR_MACH_AVR35:
2751       strncat (buf, ", avr:35", size);
2752       break;
2753     case E_AVR_MACH_AVR4:
2754       strncat (buf, ", avr:4", size);
2755       break;
2756     case E_AVR_MACH_AVR5:
2757       strncat (buf, ", avr:5", size);
2758       break;
2759     case E_AVR_MACH_AVR51:
2760       strncat (buf, ", avr:51", size);
2761       break;
2762     case E_AVR_MACH_AVR6:
2763       strncat (buf, ", avr:6", size);
2764       break;
2765     case E_AVR_MACH_AVRTINY:
2766       strncat (buf, ", avr:100", size);
2767       break;
2768     case E_AVR_MACH_XMEGA1:
2769       strncat (buf, ", avr:101", size);
2770       break;
2771     case E_AVR_MACH_XMEGA2:
2772       strncat (buf, ", avr:102", size);
2773       break;
2774     case E_AVR_MACH_XMEGA3:
2775       strncat (buf, ", avr:103", size);
2776       break;
2777     case E_AVR_MACH_XMEGA4:
2778       strncat (buf, ", avr:104", size);
2779       break;
2780     case E_AVR_MACH_XMEGA5:
2781       strncat (buf, ", avr:105", size);
2782       break;
2783     case E_AVR_MACH_XMEGA6:
2784       strncat (buf, ", avr:106", size);
2785       break;
2786     case E_AVR_MACH_XMEGA7:
2787       strncat (buf, ", avr:107", size);
2788       break;
2789     default:
2790       strncat (buf, ", avr:<unknown>", size);
2791       break;
2792     }
2793
2794   size -= strlen (buf);
2795   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2796     strncat (buf, ", link-relax", size);
2797 }
2798
2799 static void
2800 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2801 {
2802   unsigned abi;
2803   unsigned arch;
2804   unsigned config;
2805   unsigned version;
2806   bfd_boolean has_fpu = FALSE;
2807   unsigned int r = 0;
2808
2809   static const char *ABI_STRINGS[] =
2810   {
2811     "ABI v0", /* use r5 as return register; only used in N1213HC */
2812     "ABI v1", /* use r0 as return register */
2813     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814     "ABI v2fp", /* for FPU */
2815     "AABI",
2816     "ABI2 FP+"
2817   };
2818   static const char *VER_STRINGS[] =
2819   {
2820     "Andes ELF V1.3 or older",
2821     "Andes ELF V1.3.1",
2822     "Andes ELF V1.4"
2823   };
2824   static const char *ARCH_STRINGS[] =
2825   {
2826     "",
2827     "Andes Star v1.0",
2828     "Andes Star v2.0",
2829     "Andes Star v3.0",
2830     "Andes Star v3.0m"
2831   };
2832
2833   abi = EF_NDS_ABI & e_flags;
2834   arch = EF_NDS_ARCH & e_flags;
2835   config = EF_NDS_INST & e_flags;
2836   version = EF_NDS32_ELF_VERSION & e_flags;
2837
2838   memset (buf, 0, size);
2839
2840   switch (abi)
2841     {
2842     case E_NDS_ABI_V0:
2843     case E_NDS_ABI_V1:
2844     case E_NDS_ABI_V2:
2845     case E_NDS_ABI_V2FP:
2846     case E_NDS_ABI_AABI:
2847     case E_NDS_ABI_V2FP_PLUS:
2848       /* In case there are holes in the array.  */
2849       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2850       break;
2851
2852     default:
2853       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2854       break;
2855     }
2856
2857   switch (version)
2858     {
2859     case E_NDS32_ELF_VER_1_2:
2860     case E_NDS32_ELF_VER_1_3:
2861     case E_NDS32_ELF_VER_1_4:
2862       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2863       break;
2864
2865     default:
2866       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2867       break;
2868     }
2869
2870   if (E_NDS_ABI_V0 == abi)
2871     {
2872       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2873       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874       if (arch == E_NDS_ARCH_STAR_V1_0)
2875         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2876       return;
2877     }
2878
2879   switch (arch)
2880     {
2881     case E_NDS_ARCH_STAR_V1_0:
2882     case E_NDS_ARCH_STAR_V2_0:
2883     case E_NDS_ARCH_STAR_V3_0:
2884     case E_NDS_ARCH_STAR_V3_M:
2885       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2886       break;
2887
2888     default:
2889       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2890       /* ARCH version determines how the e_flags are interpreted.
2891          If it is unknown, we cannot proceed.  */
2892       return;
2893     }
2894
2895   /* Newer ABI; Now handle architecture specific flags.  */
2896   if (arch == E_NDS_ARCH_STAR_V1_0)
2897     {
2898       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2899         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2900
2901       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2902         r += snprintf (buf + r, size -r, ", MAC");
2903
2904       if (config & E_NDS32_HAS_DIV_INST)
2905         r += snprintf (buf + r, size -r, ", DIV");
2906
2907       if (config & E_NDS32_HAS_16BIT_INST)
2908         r += snprintf (buf + r, size -r, ", 16b");
2909     }
2910   else
2911     {
2912       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2913         {
2914           if (version <= E_NDS32_ELF_VER_1_3)
2915             r += snprintf (buf + r, size -r, ", [B8]");
2916           else
2917             r += snprintf (buf + r, size -r, ", EX9");
2918         }
2919
2920       if (config & E_NDS32_HAS_MAC_DX_INST)
2921         r += snprintf (buf + r, size -r, ", MAC_DX");
2922
2923       if (config & E_NDS32_HAS_DIV_DX_INST)
2924         r += snprintf (buf + r, size -r, ", DIV_DX");
2925
2926       if (config & E_NDS32_HAS_16BIT_INST)
2927         {
2928           if (version <= E_NDS32_ELF_VER_1_3)
2929             r += snprintf (buf + r, size -r, ", 16b");
2930           else
2931             r += snprintf (buf + r, size -r, ", IFC");
2932         }
2933     }
2934
2935   if (config & E_NDS32_HAS_EXT_INST)
2936     r += snprintf (buf + r, size -r, ", PERF1");
2937
2938   if (config & E_NDS32_HAS_EXT2_INST)
2939     r += snprintf (buf + r, size -r, ", PERF2");
2940
2941   if (config & E_NDS32_HAS_FPU_INST)
2942     {
2943       has_fpu = TRUE;
2944       r += snprintf (buf + r, size -r, ", FPU_SP");
2945     }
2946
2947   if (config & E_NDS32_HAS_FPU_DP_INST)
2948     {
2949       has_fpu = TRUE;
2950       r += snprintf (buf + r, size -r, ", FPU_DP");
2951     }
2952
2953   if (config & E_NDS32_HAS_FPU_MAC_INST)
2954     {
2955       has_fpu = TRUE;
2956       r += snprintf (buf + r, size -r, ", FPU_MAC");
2957     }
2958
2959   if (has_fpu)
2960     {
2961       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2962         {
2963         case E_NDS32_FPU_REG_8SP_4DP:
2964           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2965           break;
2966         case E_NDS32_FPU_REG_16SP_8DP:
2967           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2968           break;
2969         case E_NDS32_FPU_REG_32SP_16DP:
2970           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2971           break;
2972         case E_NDS32_FPU_REG_32SP_32DP:
2973           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2974           break;
2975         }
2976     }
2977
2978   if (config & E_NDS32_HAS_AUDIO_INST)
2979     r += snprintf (buf + r, size -r, ", AUDIO");
2980
2981   if (config & E_NDS32_HAS_STRING_INST)
2982     r += snprintf (buf + r, size -r, ", STR");
2983
2984   if (config & E_NDS32_HAS_REDUCED_REGS)
2985     r += snprintf (buf + r, size -r, ", 16REG");
2986
2987   if (config & E_NDS32_HAS_VIDEO_INST)
2988     {
2989       if (version <= E_NDS32_ELF_VER_1_3)
2990         r += snprintf (buf + r, size -r, ", VIDEO");
2991       else
2992         r += snprintf (buf + r, size -r, ", SATURATION");
2993     }
2994
2995   if (config & E_NDS32_HAS_ENCRIPT_INST)
2996     r += snprintf (buf + r, size -r, ", ENCRP");
2997
2998   if (config & E_NDS32_HAS_L2C_INST)
2999     r += snprintf (buf + r, size -r, ", L2C");
3000 }
3001
3002 static char *
3003 get_machine_flags (unsigned e_flags, unsigned e_machine)
3004 {
3005   static char buf[1024];
3006
3007   buf[0] = '\0';
3008
3009   if (e_flags)
3010     {
3011       switch (e_machine)
3012         {
3013         default:
3014           break;
3015
3016         case EM_ARC_COMPACT2:
3017         case EM_ARC_COMPACT:
3018           decode_ARC_machine_flags (e_flags, e_machine, buf);
3019           break;
3020
3021         case EM_ARM:
3022           decode_ARM_machine_flags (e_flags, buf);
3023           break;
3024
3025         case EM_AVR:
3026           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3027           break;
3028
3029         case EM_BLACKFIN:
3030           if (e_flags & EF_BFIN_PIC)
3031             strcat (buf, ", PIC");
3032
3033           if (e_flags & EF_BFIN_FDPIC)
3034             strcat (buf, ", FDPIC");
3035
3036           if (e_flags & EF_BFIN_CODE_IN_L1)
3037             strcat (buf, ", code in L1");
3038
3039           if (e_flags & EF_BFIN_DATA_IN_L1)
3040             strcat (buf, ", data in L1");
3041
3042           break;
3043
3044         case EM_CYGNUS_FRV:
3045           switch (e_flags & EF_FRV_CPU_MASK)
3046             {
3047             case EF_FRV_CPU_GENERIC:
3048               break;
3049
3050             default:
3051               strcat (buf, ", fr???");
3052               break;
3053
3054             case EF_FRV_CPU_FR300:
3055               strcat (buf, ", fr300");
3056               break;
3057
3058             case EF_FRV_CPU_FR400:
3059               strcat (buf, ", fr400");
3060               break;
3061             case EF_FRV_CPU_FR405:
3062               strcat (buf, ", fr405");
3063               break;
3064
3065             case EF_FRV_CPU_FR450:
3066               strcat (buf, ", fr450");
3067               break;
3068
3069             case EF_FRV_CPU_FR500:
3070               strcat (buf, ", fr500");
3071               break;
3072             case EF_FRV_CPU_FR550:
3073               strcat (buf, ", fr550");
3074               break;
3075
3076             case EF_FRV_CPU_SIMPLE:
3077               strcat (buf, ", simple");
3078               break;
3079             case EF_FRV_CPU_TOMCAT:
3080               strcat (buf, ", tomcat");
3081               break;
3082             }
3083           break;
3084
3085         case EM_68K:
3086           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3087             strcat (buf, ", m68000");
3088           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3089             strcat (buf, ", cpu32");
3090           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3091             strcat (buf, ", fido_a");
3092           else
3093             {
3094               char const * isa = _("unknown");
3095               char const * mac = _("unknown mac");
3096               char const * additional = NULL;
3097
3098               switch (e_flags & EF_M68K_CF_ISA_MASK)
3099                 {
3100                 case EF_M68K_CF_ISA_A_NODIV:
3101                   isa = "A";
3102                   additional = ", nodiv";
3103                   break;
3104                 case EF_M68K_CF_ISA_A:
3105                   isa = "A";
3106                   break;
3107                 case EF_M68K_CF_ISA_A_PLUS:
3108                   isa = "A+";
3109                   break;
3110                 case EF_M68K_CF_ISA_B_NOUSP:
3111                   isa = "B";
3112                   additional = ", nousp";
3113                   break;
3114                 case EF_M68K_CF_ISA_B:
3115                   isa = "B";
3116                   break;
3117                 case EF_M68K_CF_ISA_C:
3118                   isa = "C";
3119                   break;
3120                 case EF_M68K_CF_ISA_C_NODIV:
3121                   isa = "C";
3122                   additional = ", nodiv";
3123                   break;
3124                 }
3125               strcat (buf, ", cf, isa ");
3126               strcat (buf, isa);
3127               if (additional)
3128                 strcat (buf, additional);
3129               if (e_flags & EF_M68K_CF_FLOAT)
3130                 strcat (buf, ", float");
3131               switch (e_flags & EF_M68K_CF_MAC_MASK)
3132                 {
3133                 case 0:
3134                   mac = NULL;
3135                   break;
3136                 case EF_M68K_CF_MAC:
3137                   mac = "mac";
3138                   break;
3139                 case EF_M68K_CF_EMAC:
3140                   mac = "emac";
3141                   break;
3142                 case EF_M68K_CF_EMAC_B:
3143                   mac = "emac_b";
3144                   break;
3145                 }
3146               if (mac)
3147                 {
3148                   strcat (buf, ", ");
3149                   strcat (buf, mac);
3150                 }
3151             }
3152           break;
3153
3154         case EM_CYGNUS_MEP:
3155           switch (e_flags & EF_MEP_CPU_MASK)
3156             {
3157             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3158             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3159             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3160             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3161             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3162             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3163             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3164             }
3165
3166           switch (e_flags & EF_MEP_COP_MASK)
3167             {
3168             case EF_MEP_COP_NONE: break;
3169             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3170             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3171             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3172             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3173             default: strcat (buf, _("<unknown MeP copro type>")); break;
3174             }
3175
3176           if (e_flags & EF_MEP_LIBRARY)
3177             strcat (buf, ", Built for Library");
3178
3179           if (e_flags & EF_MEP_INDEX_MASK)
3180             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3181                      e_flags & EF_MEP_INDEX_MASK);
3182
3183           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3184             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3185                      e_flags & ~ EF_MEP_ALL_FLAGS);
3186           break;
3187
3188         case EM_PPC:
3189           if (e_flags & EF_PPC_EMB)
3190             strcat (buf, ", emb");
3191
3192           if (e_flags & EF_PPC_RELOCATABLE)
3193             strcat (buf, _(", relocatable"));
3194
3195           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3196             strcat (buf, _(", relocatable-lib"));
3197           break;
3198
3199         case EM_PPC64:
3200           if (e_flags & EF_PPC64_ABI)
3201             {
3202               char abi[] = ", abiv0";
3203
3204               abi[6] += e_flags & EF_PPC64_ABI;
3205               strcat (buf, abi);
3206             }
3207           break;
3208
3209         case EM_V800:
3210           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3211             strcat (buf, ", RH850 ABI");
3212
3213           if (e_flags & EF_V800_850E3)
3214             strcat (buf, ", V3 architecture");
3215
3216           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3217             strcat (buf, ", FPU not used");
3218
3219           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3220             strcat (buf, ", regmode: COMMON");
3221
3222           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3223             strcat (buf, ", r4 not used");
3224
3225           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3226             strcat (buf, ", r30 not used");
3227
3228           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3229             strcat (buf, ", r5 not used");
3230
3231           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3232             strcat (buf, ", r2 not used");
3233
3234           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3235             {
3236               switch (e_flags & - e_flags)
3237                 {
3238                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3239                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3240                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3241                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3242                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3243                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3244                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3245                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3246                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3247                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3248                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3249                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3250                 default: break;
3251                 }
3252             }
3253           break;
3254
3255         case EM_V850:
3256         case EM_CYGNUS_V850:
3257           switch (e_flags & EF_V850_ARCH)
3258             {
3259             case E_V850E3V5_ARCH:
3260               strcat (buf, ", v850e3v5");
3261               break;
3262             case E_V850E2V3_ARCH:
3263               strcat (buf, ", v850e2v3");
3264               break;
3265             case E_V850E2_ARCH:
3266               strcat (buf, ", v850e2");
3267               break;
3268             case E_V850E1_ARCH:
3269               strcat (buf, ", v850e1");
3270               break;
3271             case E_V850E_ARCH:
3272               strcat (buf, ", v850e");
3273               break;
3274             case E_V850_ARCH:
3275               strcat (buf, ", v850");
3276               break;
3277             default:
3278               strcat (buf, _(", unknown v850 architecture variant"));
3279               break;
3280             }
3281           break;
3282
3283         case EM_M32R:
3284         case EM_CYGNUS_M32R:
3285           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3286             strcat (buf, ", m32r");
3287           break;
3288
3289         case EM_MIPS:
3290         case EM_MIPS_RS3_LE:
3291           if (e_flags & EF_MIPS_NOREORDER)
3292             strcat (buf, ", noreorder");
3293
3294           if (e_flags & EF_MIPS_PIC)
3295             strcat (buf, ", pic");
3296
3297           if (e_flags & EF_MIPS_CPIC)
3298             strcat (buf, ", cpic");
3299
3300           if (e_flags & EF_MIPS_UCODE)
3301             strcat (buf, ", ugen_reserved");
3302
3303           if (e_flags & EF_MIPS_ABI2)
3304             strcat (buf, ", abi2");
3305
3306           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3307             strcat (buf, ", odk first");
3308
3309           if (e_flags & EF_MIPS_32BITMODE)
3310             strcat (buf, ", 32bitmode");
3311
3312           if (e_flags & EF_MIPS_NAN2008)
3313             strcat (buf, ", nan2008");
3314
3315           if (e_flags & EF_MIPS_FP64)
3316             strcat (buf, ", fp64");
3317
3318           switch ((e_flags & EF_MIPS_MACH))
3319             {
3320             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3321             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3322             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3323             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3324             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3325             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3326             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3327             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3328             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3329             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3330             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3331             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3332             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3333             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3334             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3335             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3336             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3337             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3338             case 0:
3339             /* We simply ignore the field in this case to avoid confusion:
3340                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3341                extension.  */
3342               break;
3343             default: strcat (buf, _(", unknown CPU")); break;
3344             }
3345
3346           switch ((e_flags & EF_MIPS_ABI))
3347             {
3348             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3349             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3350             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3351             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3352             case 0:
3353             /* We simply ignore the field in this case to avoid confusion:
3354                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3355                This means it is likely to be an o32 file, but not for
3356                sure.  */
3357               break;
3358             default: strcat (buf, _(", unknown ABI")); break;
3359             }
3360
3361           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3362             strcat (buf, ", mdmx");
3363
3364           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3365             strcat (buf, ", mips16");
3366
3367           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3368             strcat (buf, ", micromips");
3369
3370           switch ((e_flags & EF_MIPS_ARCH))
3371             {
3372             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3373             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3374             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3375             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3376             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3377             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3378             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3379             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3380             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3381             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3382             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3383             default: strcat (buf, _(", unknown ISA")); break;
3384             }
3385           break;
3386
3387         case EM_NDS32:
3388           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3389           break;
3390
3391         case EM_RISCV:
3392           if (e_flags & EF_RISCV_RVC)
3393             strcat (buf, ", RVC");
3394
3395           switch (e_flags & EF_RISCV_FLOAT_ABI)
3396             {
3397             case EF_RISCV_FLOAT_ABI_SOFT:
3398               strcat (buf, ", soft-float ABI");
3399               break;
3400
3401             case EF_RISCV_FLOAT_ABI_SINGLE:
3402               strcat (buf, ", single-float ABI");
3403               break;
3404
3405             case EF_RISCV_FLOAT_ABI_DOUBLE:
3406               strcat (buf, ", double-float ABI");
3407               break;
3408
3409             case EF_RISCV_FLOAT_ABI_QUAD:
3410               strcat (buf, ", quad-float ABI");
3411               break;
3412             }
3413           break;
3414
3415         case EM_SH:
3416           switch ((e_flags & EF_SH_MACH_MASK))
3417             {
3418             case EF_SH1: strcat (buf, ", sh1"); break;
3419             case EF_SH2: strcat (buf, ", sh2"); break;
3420             case EF_SH3: strcat (buf, ", sh3"); break;
3421             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3422             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3423             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3424             case EF_SH3E: strcat (buf, ", sh3e"); break;
3425             case EF_SH4: strcat (buf, ", sh4"); break;
3426             case EF_SH5: strcat (buf, ", sh5"); break;
3427             case EF_SH2E: strcat (buf, ", sh2e"); break;
3428             case EF_SH4A: strcat (buf, ", sh4a"); break;
3429             case EF_SH2A: strcat (buf, ", sh2a"); break;
3430             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3431             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3432             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3433             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3434             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3435             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3436             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3437             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3438             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3439             default: strcat (buf, _(", unknown ISA")); break;
3440             }
3441
3442           if (e_flags & EF_SH_PIC)
3443             strcat (buf, ", pic");
3444
3445           if (e_flags & EF_SH_FDPIC)
3446             strcat (buf, ", fdpic");
3447           break;
3448
3449         case EM_OR1K:
3450           if (e_flags & EF_OR1K_NODELAY)
3451             strcat (buf, ", no delay");
3452           break;
3453
3454         case EM_SPARCV9:
3455           if (e_flags & EF_SPARC_32PLUS)
3456             strcat (buf, ", v8+");
3457
3458           if (e_flags & EF_SPARC_SUN_US1)
3459             strcat (buf, ", ultrasparcI");
3460
3461           if (e_flags & EF_SPARC_SUN_US3)
3462             strcat (buf, ", ultrasparcIII");
3463
3464           if (e_flags & EF_SPARC_HAL_R1)
3465             strcat (buf, ", halr1");
3466
3467           if (e_flags & EF_SPARC_LEDATA)
3468             strcat (buf, ", ledata");
3469
3470           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3471             strcat (buf, ", tso");
3472
3473           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3474             strcat (buf, ", pso");
3475
3476           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3477             strcat (buf, ", rmo");
3478           break;
3479
3480         case EM_PARISC:
3481           switch (e_flags & EF_PARISC_ARCH)
3482             {
3483             case EFA_PARISC_1_0:
3484               strcpy (buf, ", PA-RISC 1.0");
3485               break;
3486             case EFA_PARISC_1_1:
3487               strcpy (buf, ", PA-RISC 1.1");
3488               break;
3489             case EFA_PARISC_2_0:
3490               strcpy (buf, ", PA-RISC 2.0");
3491               break;
3492             default:
3493               break;
3494             }
3495           if (e_flags & EF_PARISC_TRAPNIL)
3496             strcat (buf, ", trapnil");
3497           if (e_flags & EF_PARISC_EXT)
3498             strcat (buf, ", ext");
3499           if (e_flags & EF_PARISC_LSB)
3500             strcat (buf, ", lsb");
3501           if (e_flags & EF_PARISC_WIDE)
3502             strcat (buf, ", wide");
3503           if (e_flags & EF_PARISC_NO_KABP)
3504             strcat (buf, ", no kabp");
3505           if (e_flags & EF_PARISC_LAZYSWAP)
3506             strcat (buf, ", lazyswap");
3507           break;
3508
3509         case EM_PJ:
3510         case EM_PJ_OLD:
3511           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3512             strcat (buf, ", new calling convention");
3513
3514           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3515             strcat (buf, ", gnu calling convention");
3516           break;
3517
3518         case EM_IA_64:
3519           if ((e_flags & EF_IA_64_ABI64))
3520             strcat (buf, ", 64-bit");
3521           else
3522             strcat (buf, ", 32-bit");
3523           if ((e_flags & EF_IA_64_REDUCEDFP))
3524             strcat (buf, ", reduced fp model");
3525           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3526             strcat (buf, ", no function descriptors, constant gp");
3527           else if ((e_flags & EF_IA_64_CONS_GP))
3528             strcat (buf, ", constant gp");
3529           if ((e_flags & EF_IA_64_ABSOLUTE))
3530             strcat (buf, ", absolute");
3531           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3532             {
3533               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3534                 strcat (buf, ", vms_linkages");
3535               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3536                 {
3537                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3538                   break;
3539                 case EF_IA_64_VMS_COMCOD_WARNING:
3540                   strcat (buf, ", warning");
3541                   break;
3542                 case EF_IA_64_VMS_COMCOD_ERROR:
3543                   strcat (buf, ", error");
3544                   break;
3545                 case EF_IA_64_VMS_COMCOD_ABORT:
3546                   strcat (buf, ", abort");
3547                   break;
3548                 default:
3549                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3550                         e_flags & EF_IA_64_VMS_COMCOD);
3551                   strcat (buf, ", <unknown>");
3552                 }
3553             }
3554           break;
3555
3556         case EM_VAX:
3557           if ((e_flags & EF_VAX_NONPIC))
3558             strcat (buf, ", non-PIC");
3559           if ((e_flags & EF_VAX_DFLOAT))
3560             strcat (buf, ", D-Float");
3561           if ((e_flags & EF_VAX_GFLOAT))
3562             strcat (buf, ", G-Float");
3563           break;
3564
3565         case EM_VISIUM:
3566           if (e_flags & EF_VISIUM_ARCH_MCM)
3567             strcat (buf, ", mcm");
3568           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3569             strcat (buf, ", mcm24");
3570           if (e_flags & EF_VISIUM_ARCH_GR6)
3571             strcat (buf, ", gr6");
3572           break;
3573
3574         case EM_RL78:
3575           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3576             {
3577             case E_FLAG_RL78_ANY_CPU: break;
3578             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3579             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3580             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3581             }
3582           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3583             strcat (buf, ", 64-bit doubles");
3584           break;
3585
3586         case EM_RX:
3587           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3588             strcat (buf, ", 64-bit doubles");
3589           if (e_flags & E_FLAG_RX_DSP)
3590             strcat (buf, ", dsp");
3591           if (e_flags & E_FLAG_RX_PID)
3592             strcat (buf, ", pid");
3593           if (e_flags & E_FLAG_RX_ABI)
3594             strcat (buf, ", RX ABI");
3595           if (e_flags & E_FLAG_RX_SINSNS_SET)
3596             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3597                     ? ", uses String instructions" : ", bans String instructions");
3598           if (e_flags & E_FLAG_RX_V2)
3599             strcat (buf, ", V2");
3600           break;
3601
3602         case EM_S390:
3603           if (e_flags & EF_S390_HIGH_GPRS)
3604             strcat (buf, ", highgprs");
3605           break;
3606
3607         case EM_TI_C6000:
3608           if ((e_flags & EF_C6000_REL))
3609             strcat (buf, ", relocatable module");
3610           break;
3611
3612         case EM_MSP430:
3613           strcat (buf, _(": architecture variant: "));
3614           switch (e_flags & EF_MSP430_MACH)
3615             {
3616             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3617             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3618             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3619             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3620             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3621             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3622             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3623             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3624             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3625             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3626             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3627             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3628             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3629             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3630             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3631             default:
3632               strcat (buf, _(": unknown")); break;
3633             }
3634
3635           if (e_flags & ~ EF_MSP430_MACH)
3636             strcat (buf, _(": unknown extra flag bits also present"));
3637         }
3638     }
3639
3640   return buf;
3641 }
3642
3643 static const char *
3644 get_osabi_name (unsigned int osabi)
3645 {
3646   static char buff[32];
3647
3648   switch (osabi)
3649     {
3650     case ELFOSABI_NONE:         return "UNIX - System V";
3651     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3652     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3653     case ELFOSABI_GNU:          return "UNIX - GNU";
3654     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3655     case ELFOSABI_AIX:          return "UNIX - AIX";
3656     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3657     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3658     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3659     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3660     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3661     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3662     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3663     case ELFOSABI_AROS:         return "AROS";
3664     case ELFOSABI_FENIXOS:      return "FenixOS";
3665     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3666     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3667     default:
3668       if (osabi >= 64)
3669         switch (elf_header.e_machine)
3670           {
3671           case EM_ARM:
3672             switch (osabi)
3673               {
3674               case ELFOSABI_ARM:        return "ARM";
3675               default:
3676                 break;
3677               }
3678             break;
3679
3680           case EM_MSP430:
3681           case EM_MSP430_OLD:
3682           case EM_VISIUM:
3683             switch (osabi)
3684               {
3685               case ELFOSABI_STANDALONE: return _("Standalone App");
3686               default:
3687                 break;
3688               }
3689             break;
3690
3691           case EM_TI_C6000:
3692             switch (osabi)
3693               {
3694               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3695               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3696               default:
3697                 break;
3698               }
3699             break;
3700
3701           default:
3702             break;
3703           }
3704       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3705       return buff;
3706     }
3707 }
3708
3709 static const char *
3710 get_aarch64_segment_type (unsigned long type)
3711 {
3712   switch (type)
3713     {
3714     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3715     default:                  return NULL;
3716     }
3717 }
3718
3719 static const char *
3720 get_arm_segment_type (unsigned long type)
3721 {
3722   switch (type)
3723     {
3724     case PT_ARM_EXIDX: return "EXIDX";
3725     default:           return NULL;
3726     }
3727 }
3728
3729 static const char *
3730 get_s390_segment_type (unsigned long type)
3731 {
3732   switch (type)
3733     {
3734     case PT_S390_PGSTE: return "S390_PGSTE";
3735     default:            return NULL;
3736     }
3737 }
3738
3739 static const char *
3740 get_mips_segment_type (unsigned long type)
3741 {
3742   switch (type)
3743     {
3744     case PT_MIPS_REGINFO:   return "REGINFO";
3745     case PT_MIPS_RTPROC:    return "RTPROC";
3746     case PT_MIPS_OPTIONS:   return "OPTIONS";
3747     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3748     default:                return NULL;
3749     }
3750 }
3751
3752 static const char *
3753 get_parisc_segment_type (unsigned long type)
3754 {
3755   switch (type)
3756     {
3757     case PT_HP_TLS:             return "HP_TLS";
3758     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3759     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3760     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3761     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3762     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3763     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3764     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3765     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3766     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3767     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3768     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3769     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3770     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3771     case PT_HP_STACK:           return "HP_STACK";
3772     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3773     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3774     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3775     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3776     default:                    return NULL;
3777     }
3778 }
3779
3780 static const char *
3781 get_ia64_segment_type (unsigned long type)
3782 {
3783   switch (type)
3784     {
3785     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3786     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3787     case PT_HP_TLS:             return "HP_TLS";
3788     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3789     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3790     case PT_IA_64_HP_STACK:     return "HP_STACK";
3791     default:                    return NULL;
3792     }
3793 }
3794
3795 static const char *
3796 get_tic6x_segment_type (unsigned long type)
3797 {
3798   switch (type)
3799     {
3800     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3801     default:               return NULL;
3802     }
3803 }
3804
3805 static const char *
3806 get_solaris_segment_type (unsigned long type)
3807 {
3808   switch (type)
3809     {
3810     case 0x6464e550: return "PT_SUNW_UNWIND";
3811     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3812     case 0x6ffffff7: return "PT_LOSUNW";
3813     case 0x6ffffffa: return "PT_SUNWBSS";
3814     case 0x6ffffffb: return "PT_SUNWSTACK";
3815     case 0x6ffffffc: return "PT_SUNWDTRACE";
3816     case 0x6ffffffd: return "PT_SUNWCAP";
3817     case 0x6fffffff: return "PT_HISUNW";
3818     default:         return NULL;
3819     }
3820 }
3821
3822 static const char *
3823 get_segment_type (unsigned long p_type)
3824 {
3825   static char buff[32];
3826
3827   switch (p_type)
3828     {
3829     case PT_NULL:       return "NULL";
3830     case PT_LOAD:       return "LOAD";
3831     case PT_DYNAMIC:    return "DYNAMIC";
3832     case PT_INTERP:     return "INTERP";
3833     case PT_NOTE:       return "NOTE";
3834     case PT_SHLIB:      return "SHLIB";
3835     case PT_PHDR:       return "PHDR";
3836     case PT_TLS:        return "TLS";
3837     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3838     case PT_GNU_STACK:  return "GNU_STACK";
3839     case PT_GNU_RELRO:  return "GNU_RELRO";
3840
3841     default:
3842       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3843         {
3844           sprintf (buff, "GNU_MBIND+%#lx",
3845                    p_type - PT_GNU_MBIND_LO);
3846         }
3847       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3848         {
3849           const char * result;
3850
3851           switch (elf_header.e_machine)
3852             {
3853             case EM_AARCH64:
3854               result = get_aarch64_segment_type (p_type);
3855               break;
3856             case EM_ARM:
3857               result = get_arm_segment_type (p_type);
3858               break;
3859             case EM_MIPS:
3860             case EM_MIPS_RS3_LE:
3861               result = get_mips_segment_type (p_type);
3862               break;
3863             case EM_PARISC:
3864               result = get_parisc_segment_type (p_type);
3865               break;
3866             case EM_IA_64:
3867               result = get_ia64_segment_type (p_type);
3868               break;
3869             case EM_TI_C6000:
3870               result = get_tic6x_segment_type (p_type);
3871               break;
3872             case EM_S390:
3873             case EM_S390_OLD:
3874               result = get_s390_segment_type (p_type);
3875               break;
3876             default:
3877               result = NULL;
3878               break;
3879             }
3880
3881           if (result != NULL)
3882             return result;
3883
3884           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3885         }
3886       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3887         {
3888           const char * result;
3889
3890           switch (elf_header.e_machine)
3891             {
3892             case EM_PARISC:
3893               result = get_parisc_segment_type (p_type);
3894               break;
3895             case EM_IA_64:
3896               result = get_ia64_segment_type (p_type);
3897               break;
3898             default:
3899               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3900                 result = get_solaris_segment_type (p_type);
3901               else
3902                 result = NULL;
3903               break;
3904             }
3905
3906           if (result != NULL)
3907             return result;
3908
3909           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3910         }
3911       else
3912         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3913
3914       return buff;
3915     }
3916 }
3917
3918 static const char *
3919 get_arc_section_type_name (unsigned int sh_type)
3920 {
3921   switch (sh_type)
3922     {
3923     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3924     default:
3925       break;
3926     }
3927   return NULL;
3928 }
3929
3930 static const char *
3931 get_mips_section_type_name (unsigned int sh_type)
3932 {
3933   switch (sh_type)
3934     {
3935     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3936     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3937     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3938     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3939     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3940     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3941     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3942     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3943     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3944     case SHT_MIPS_RELD:          return "MIPS_RELD";
3945     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3946     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3947     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3948     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3949     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3950     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3951     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3952     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3953     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3954     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3955     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3956     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3957     case SHT_MIPS_LINE:          return "MIPS_LINE";
3958     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3959     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3960     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3961     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3962     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3963     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3964     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3965     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3966     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3967     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3968     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3969     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3970     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3971     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3972     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3973     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3974     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3975     default:
3976       break;
3977     }
3978   return NULL;
3979 }
3980
3981 static const char *
3982 get_parisc_section_type_name (unsigned int sh_type)
3983 {
3984   switch (sh_type)
3985     {
3986     case SHT_PARISC_EXT:        return "PARISC_EXT";
3987     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3988     case SHT_PARISC_DOC:        return "PARISC_DOC";
3989     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3990     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3991     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3992     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3993     default:                    return NULL;
3994     }
3995 }
3996
3997 static const char *
3998 get_ia64_section_type_name (unsigned int sh_type)
3999 {
4000   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4001   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4002     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
4003
4004   switch (sh_type)
4005     {
4006     case SHT_IA_64_EXT:                return "IA_64_EXT";
4007     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4008     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4009     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4010     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4011     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4012     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4013     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4014     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4015     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4016     default:
4017       break;
4018     }
4019   return NULL;
4020 }
4021
4022 static const char *
4023 get_x86_64_section_type_name (unsigned int sh_type)
4024 {
4025   switch (sh_type)
4026     {
4027     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4028     default:                    return NULL;
4029     }
4030 }
4031
4032 static const char *
4033 get_aarch64_section_type_name (unsigned int sh_type)
4034 {
4035   switch (sh_type)
4036     {
4037     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4038     default:                     return NULL;
4039     }
4040 }
4041
4042 static const char *
4043 get_arm_section_type_name (unsigned int sh_type)
4044 {
4045   switch (sh_type)
4046     {
4047     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4048     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4049     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4050     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4051     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4052     default:                      return NULL;
4053     }
4054 }
4055
4056 static const char *
4057 get_tic6x_section_type_name (unsigned int sh_type)
4058 {
4059   switch (sh_type)
4060     {
4061     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4062     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4063     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4064     case SHT_TI_ICODE:          return "TI_ICODE";
4065     case SHT_TI_XREF:           return "TI_XREF";
4066     case SHT_TI_HANDLER:        return "TI_HANDLER";
4067     case SHT_TI_INITINFO:       return "TI_INITINFO";
4068     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4069     default:                    return NULL;
4070     }
4071 }
4072
4073 static const char *
4074 get_msp430x_section_type_name (unsigned int sh_type)
4075 {
4076   switch (sh_type)
4077     {
4078     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4079     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4080     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4081     default:                      return NULL;
4082     }
4083 }
4084
4085 static const char *
4086 get_v850_section_type_name (unsigned int sh_type)
4087 {
4088   switch (sh_type)
4089     {
4090     case SHT_V850_SCOMMON:  return "V850 Small Common";
4091     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4092     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4093     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4094     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4095     default:                return NULL;
4096     }
4097 }
4098
4099 static const char *
4100 get_section_type_name (unsigned int sh_type)
4101 {
4102   static char buff[32];
4103   const char * result;
4104
4105   switch (sh_type)
4106     {
4107     case SHT_NULL:              return "NULL";
4108     case SHT_PROGBITS:          return "PROGBITS";
4109     case SHT_SYMTAB:            return "SYMTAB";
4110     case SHT_STRTAB:            return "STRTAB";
4111     case SHT_RELA:              return "RELA";
4112     case SHT_HASH:              return "HASH";
4113     case SHT_DYNAMIC:           return "DYNAMIC";
4114     case SHT_NOTE:              return "NOTE";
4115     case SHT_NOBITS:            return "NOBITS";
4116     case SHT_REL:               return "REL";
4117     case SHT_SHLIB:             return "SHLIB";
4118     case SHT_DYNSYM:            return "DYNSYM";
4119     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4120     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4121     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4122     case SHT_GNU_HASH:          return "GNU_HASH";
4123     case SHT_GROUP:             return "GROUP";
4124     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4125     case SHT_GNU_verdef:        return "VERDEF";
4126     case SHT_GNU_verneed:       return "VERNEED";
4127     case SHT_GNU_versym:        return "VERSYM";
4128     case 0x6ffffff0:            return "VERSYM";
4129     case 0x6ffffffc:            return "VERDEF";
4130     case 0x7ffffffd:            return "AUXILIARY";
4131     case 0x7fffffff:            return "FILTER";
4132     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4133
4134     default:
4135       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4136         {
4137           switch (elf_header.e_machine)
4138             {
4139             case EM_ARC:
4140             case EM_ARC_COMPACT:
4141             case EM_ARC_COMPACT2:
4142               result = get_arc_section_type_name (sh_type);
4143               break;
4144             case EM_MIPS:
4145             case EM_MIPS_RS3_LE:
4146               result = get_mips_section_type_name (sh_type);
4147               break;
4148             case EM_PARISC:
4149               result = get_parisc_section_type_name (sh_type);
4150               break;
4151             case EM_IA_64:
4152               result = get_ia64_section_type_name (sh_type);
4153               break;
4154             case EM_X86_64:
4155             case EM_L1OM:
4156             case EM_K1OM:
4157               result = get_x86_64_section_type_name (sh_type);
4158               break;
4159             case EM_AARCH64:
4160               result = get_aarch64_section_type_name (sh_type);
4161               break;
4162             case EM_ARM:
4163               result = get_arm_section_type_name (sh_type);
4164               break;
4165             case EM_TI_C6000:
4166               result = get_tic6x_section_type_name (sh_type);
4167               break;
4168             case EM_MSP430:
4169               result = get_msp430x_section_type_name (sh_type);
4170               break;
4171             case EM_V800:
4172             case EM_V850:
4173             case EM_CYGNUS_V850:
4174               result = get_v850_section_type_name (sh_type);
4175               break;
4176             default:
4177               result = NULL;
4178               break;
4179             }
4180
4181           if (result != NULL)
4182             return result;
4183
4184           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4185         }
4186       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4187         {
4188           switch (elf_header.e_machine)
4189             {
4190             case EM_IA_64:
4191               result = get_ia64_section_type_name (sh_type);
4192               break;
4193             default:
4194               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4195                 result = get_solaris_section_type (sh_type);
4196               else
4197                 {
4198                   switch (sh_type)
4199                     {
4200                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4201                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4202                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4203                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4204                     default:
4205                       result = NULL;
4206                       break;
4207                     }
4208                 }
4209               break;
4210             }
4211
4212           if (result != NULL)
4213             return result;
4214
4215           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4216         }
4217       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4218         {
4219           switch (elf_header.e_machine)
4220             {
4221             case EM_V800:
4222             case EM_V850:
4223             case EM_CYGNUS_V850:
4224               result = get_v850_section_type_name (sh_type);
4225               break;
4226             default:
4227               result = NULL;
4228               break;
4229             }
4230
4231           if (result != NULL)
4232             return result;
4233
4234           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4235         }
4236       else
4237         /* This message is probably going to be displayed in a 15
4238            character wide field, so put the hex value first.  */
4239         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4240
4241       return buff;
4242     }
4243 }
4244
4245 #define OPTION_DEBUG_DUMP       512
4246 #define OPTION_DYN_SYMS         513
4247 #define OPTION_DWARF_DEPTH      514
4248 #define OPTION_DWARF_START      515
4249 #define OPTION_DWARF_CHECK      516
4250
4251 static struct option options[] =
4252 {
4253   {"all",              no_argument, 0, 'a'},
4254   {"file-header",      no_argument, 0, 'h'},
4255   {"program-headers",  no_argument, 0, 'l'},
4256   {"headers",          no_argument, 0, 'e'},
4257   {"histogram",        no_argument, 0, 'I'},
4258   {"segments",         no_argument, 0, 'l'},
4259   {"sections",         no_argument, 0, 'S'},
4260   {"section-headers",  no_argument, 0, 'S'},
4261   {"section-groups",   no_argument, 0, 'g'},
4262   {"section-details",  no_argument, 0, 't'},
4263   {"full-section-name",no_argument, 0, 'N'},
4264   {"symbols",          no_argument, 0, 's'},
4265   {"syms",             no_argument, 0, 's'},
4266   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4267   {"relocs",           no_argument, 0, 'r'},
4268   {"notes",            no_argument, 0, 'n'},
4269   {"dynamic",          no_argument, 0, 'd'},
4270   {"arch-specific",    no_argument, 0, 'A'},
4271   {"version-info",     no_argument, 0, 'V'},
4272   {"use-dynamic",      no_argument, 0, 'D'},
4273   {"unwind",           no_argument, 0, 'u'},
4274   {"archive-index",    no_argument, 0, 'c'},
4275   {"hex-dump",         required_argument, 0, 'x'},
4276   {"relocated-dump",   required_argument, 0, 'R'},
4277   {"string-dump",      required_argument, 0, 'p'},
4278   {"decompress",       no_argument, 0, 'z'},
4279 #ifdef SUPPORT_DISASSEMBLY
4280   {"instruction-dump", required_argument, 0, 'i'},
4281 #endif
4282   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4283
4284   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4285   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4286   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4287
4288   {"version",          no_argument, 0, 'v'},
4289   {"wide",             no_argument, 0, 'W'},
4290   {"help",             no_argument, 0, 'H'},
4291   {0,                  no_argument, 0, 0}
4292 };
4293
4294 static void
4295 usage (FILE * stream)
4296 {
4297   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4298   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4299   fprintf (stream, _(" Options are:\n\
4300   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4301   -h --file-header       Display the ELF file header\n\
4302   -l --program-headers   Display the program headers\n\
4303      --segments          An alias for --program-headers\n\
4304   -S --section-headers   Display the sections' header\n\
4305      --sections          An alias for --section-headers\n\
4306   -g --section-groups    Display the section groups\n\
4307   -t --section-details   Display the section details\n\
4308   -e --headers           Equivalent to: -h -l -S\n\
4309   -s --syms              Display the symbol table\n\
4310      --symbols           An alias for --syms\n\
4311   --dyn-syms             Display the dynamic symbol table\n\
4312   -n --notes             Display the core notes (if present)\n\
4313   -r --relocs            Display the relocations (if present)\n\
4314   -u --unwind            Display the unwind info (if present)\n\
4315   -d --dynamic           Display the dynamic section (if present)\n\
4316   -V --version-info      Display the version sections (if present)\n\
4317   -A --arch-specific     Display architecture specific information (if any)\n\
4318   -c --archive-index     Display the symbol/file index in an archive\n\
4319   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4320   -x --hex-dump=<number|name>\n\
4321                          Dump the contents of section <number|name> as bytes\n\
4322   -p --string-dump=<number|name>\n\
4323                          Dump the contents of section <number|name> as strings\n\
4324   -R --relocated-dump=<number|name>\n\
4325                          Dump the contents of section <number|name> as relocated bytes\n\
4326   -z --decompress        Decompress section before dumping it\n\
4327   -w[lLiaprmfFsoRt] or\n\
4328   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4329                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4330                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4331                =addr,=cu_index]\n\
4332                          Display the contents of DWARF2 debug sections\n"));
4333   fprintf (stream, _("\
4334   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4335   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4336                          or deeper\n"));
4337 #ifdef SUPPORT_DISASSEMBLY
4338   fprintf (stream, _("\
4339   -i --instruction-dump=<number|name>\n\
4340                          Disassemble the contents of section <number|name>\n"));
4341 #endif
4342   fprintf (stream, _("\
4343   -I --histogram         Display histogram of bucket list lengths\n\
4344   -W --wide              Allow output width to exceed 80 characters\n\
4345   @<file>                Read options from <file>\n\
4346   -H --help              Display this information\n\
4347   -v --version           Display the version number of readelf\n"));
4348
4349   if (REPORT_BUGS_TO[0] && stream == stdout)
4350     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4351
4352   exit (stream == stdout ? 0 : 1);
4353 }
4354
4355 /* Record the fact that the user wants the contents of section number
4356    SECTION to be displayed using the method(s) encoded as flags bits
4357    in TYPE.  Note, TYPE can be zero if we are creating the array for
4358    the first time.  */
4359
4360 static void
4361 request_dump_bynumber (unsigned int section, dump_type type)
4362 {
4363   if (section >= num_dump_sects)
4364     {
4365       dump_type * new_dump_sects;
4366
4367       new_dump_sects = (dump_type *) calloc (section + 1,
4368                                              sizeof (* dump_sects));
4369
4370       if (new_dump_sects == NULL)
4371         error (_("Out of memory allocating dump request table.\n"));
4372       else
4373         {
4374           if (dump_sects)
4375             {
4376               /* Copy current flag settings.  */
4377               memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4378
4379               free (dump_sects);
4380             }
4381
4382           dump_sects = new_dump_sects;
4383           num_dump_sects = section + 1;
4384         }
4385     }
4386
4387   if (dump_sects)
4388     dump_sects[section] |= type;
4389
4390   return;
4391 }
4392
4393 /* Request a dump by section name.  */
4394
4395 static void
4396 request_dump_byname (const char * section, dump_type type)
4397 {
4398   struct dump_list_entry * new_request;
4399
4400   new_request = (struct dump_list_entry *)
4401       malloc (sizeof (struct dump_list_entry));
4402   if (!new_request)
4403     error (_("Out of memory allocating dump request table.\n"));
4404
4405   new_request->name = strdup (section);
4406   if (!new_request->name)
4407     error (_("Out of memory allocating dump request table.\n"));
4408
4409   new_request->type = type;
4410
4411   new_request->next = dump_sects_byname;
4412   dump_sects_byname = new_request;
4413 }
4414
4415 static inline void
4416 request_dump (dump_type type)
4417 {
4418   int section;
4419   char * cp;
4420
4421   do_dump++;
4422   section = strtoul (optarg, & cp, 0);
4423
4424   if (! *cp && section >= 0)
4425     request_dump_bynumber (section, type);
4426   else
4427     request_dump_byname (optarg, type);
4428 }
4429
4430
4431 static void
4432 parse_args (int argc, char ** argv)
4433 {
4434   int c;
4435
4436   if (argc < 2)
4437     usage (stderr);
4438
4439   while ((c = getopt_long
4440           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4441     {
4442       switch (c)
4443         {
4444         case 0:
4445           /* Long options.  */
4446           break;
4447         case 'H':
4448           usage (stdout);
4449           break;
4450
4451         case 'a':
4452           do_syms = TRUE;
4453           do_reloc = TRUE;
4454           do_unwind = TRUE;
4455           do_dynamic = TRUE;
4456           do_header = TRUE;
4457           do_sections = TRUE;
4458           do_section_groups = TRUE;
4459           do_segments = TRUE;
4460           do_version = TRUE;
4461           do_histogram = TRUE;
4462           do_arch = TRUE;
4463           do_notes = TRUE;
4464           break;
4465         case 'g':
4466           do_section_groups = TRUE;
4467           break;
4468         case 't':
4469         case 'N':
4470           do_sections = TRUE;
4471           do_section_details = TRUE;
4472           break;
4473         case 'e':
4474           do_header = TRUE;
4475           do_sections = TRUE;
4476           do_segments = TRUE;
4477           break;
4478         case 'A':
4479           do_arch = TRUE;
4480           break;
4481         case 'D':
4482           do_using_dynamic = TRUE;
4483           break;
4484         case 'r':
4485           do_reloc = TRUE;
4486           break;
4487         case 'u':
4488           do_unwind = TRUE;
4489           break;
4490         case 'h':
4491           do_header = TRUE;
4492           break;
4493         case 'l':
4494           do_segments = TRUE;
4495           break;
4496         case 's':
4497           do_syms = TRUE;
4498           break;
4499         case 'S':
4500           do_sections = TRUE;
4501           break;
4502         case 'd':
4503           do_dynamic = TRUE;
4504           break;
4505         case 'I':
4506           do_histogram = TRUE;
4507           break;
4508         case 'n':
4509           do_notes = TRUE;
4510           break;
4511         case 'c':
4512           do_archive_index = TRUE;
4513           break;
4514         case 'x':
4515           request_dump (HEX_DUMP);
4516           break;
4517         case 'p':
4518           request_dump (STRING_DUMP);
4519           break;
4520         case 'R':
4521           request_dump (RELOC_DUMP);
4522           break;
4523         case 'z':
4524           decompress_dumps = TRUE;
4525           break;
4526         case 'w':
4527           do_dump = TRUE;
4528           if (optarg == 0)
4529             {
4530               do_debugging = TRUE;
4531               dwarf_select_sections_all ();
4532             }
4533           else
4534             {
4535               do_debugging = FALSE;
4536               dwarf_select_sections_by_letters (optarg);
4537             }
4538           break;
4539         case OPTION_DEBUG_DUMP:
4540           do_dump = TRUE;
4541           if (optarg == 0)
4542             do_debugging = TRUE;
4543           else
4544             {
4545               do_debugging = FALSE;
4546               dwarf_select_sections_by_names (optarg);
4547             }
4548           break;
4549         case OPTION_DWARF_DEPTH:
4550           {
4551             char *cp;
4552
4553             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4554           }
4555           break;
4556         case OPTION_DWARF_START:
4557           {
4558             char *cp;
4559
4560             dwarf_start_die = strtoul (optarg, & cp, 0);
4561           }
4562           break;
4563         case OPTION_DWARF_CHECK:
4564           dwarf_check = TRUE;
4565           break;
4566         case OPTION_DYN_SYMS:
4567           do_dyn_syms = TRUE;
4568           break;
4569 #ifdef SUPPORT_DISASSEMBLY
4570         case 'i':
4571           request_dump (DISASS_DUMP);
4572           break;
4573 #endif
4574         case 'v':
4575           print_version (program_name);
4576           break;
4577         case 'V':
4578           do_version = TRUE;
4579           break;
4580         case 'W':
4581           do_wide = TRUE;
4582           break;
4583         default:
4584           /* xgettext:c-format */
4585           error (_("Invalid option '-%c'\n"), c);
4586           /* Fall through.  */
4587         case '?':
4588           usage (stderr);
4589         }
4590     }
4591
4592   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4593       && !do_segments && !do_header && !do_dump && !do_version
4594       && !do_histogram && !do_debugging && !do_arch && !do_notes
4595       && !do_section_groups && !do_archive_index
4596       && !do_dyn_syms)
4597     usage (stderr);
4598 }
4599
4600 static const char *
4601 get_elf_class (unsigned int elf_class)
4602 {
4603   static char buff[32];
4604
4605   switch (elf_class)
4606     {
4607     case ELFCLASSNONE: return _("none");
4608     case ELFCLASS32:   return "ELF32";
4609     case ELFCLASS64:   return "ELF64";
4610     default:
4611       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4612       return buff;
4613     }
4614 }
4615
4616 static const char *
4617 get_data_encoding (unsigned int encoding)
4618 {
4619   static char buff[32];
4620
4621   switch (encoding)
4622     {
4623     case ELFDATANONE: return _("none");
4624     case ELFDATA2LSB: return _("2's complement, little endian");
4625     case ELFDATA2MSB: return _("2's complement, big endian");
4626     default:
4627       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4628       return buff;
4629     }
4630 }
4631
4632 /* Decode the data held in 'elf_header'.  */
4633
4634 static bfd_boolean
4635 process_file_header (void)
4636 {
4637   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4638       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4639       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4640       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4641     {
4642       error
4643         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4644       return FALSE;
4645     }
4646
4647   init_dwarf_regnames (elf_header.e_machine);
4648
4649   if (do_header)
4650     {
4651       unsigned i;
4652
4653       printf (_("ELF Header:\n"));
4654       printf (_("  Magic:   "));
4655       for (i = 0; i < EI_NIDENT; i++)
4656         printf ("%2.2x ", elf_header.e_ident[i]);
4657       printf ("\n");
4658       printf (_("  Class:                             %s\n"),
4659               get_elf_class (elf_header.e_ident[EI_CLASS]));
4660       printf (_("  Data:                              %s\n"),
4661               get_data_encoding (elf_header.e_ident[EI_DATA]));
4662       printf (_("  Version:                           %d %s\n"),
4663               elf_header.e_ident[EI_VERSION],
4664               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4665                ? "(current)"
4666                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4667                   ? _("<unknown: %lx>")
4668                   : "")));
4669       printf (_("  OS/ABI:                            %s\n"),
4670               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4671       printf (_("  ABI Version:                       %d\n"),
4672               elf_header.e_ident[EI_ABIVERSION]);
4673       printf (_("  Type:                              %s\n"),
4674               get_file_type (elf_header.e_type));
4675       printf (_("  Machine:                           %s\n"),
4676               get_machine_name (elf_header.e_machine));
4677       printf (_("  Version:                           0x%lx\n"),
4678               (unsigned long) elf_header.e_version);
4679
4680       printf (_("  Entry point address:               "));
4681       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4682       printf (_("\n  Start of program headers:          "));
4683       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4684       printf (_(" (bytes into file)\n  Start of section headers:          "));
4685       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4686       printf (_(" (bytes into file)\n"));
4687
4688       printf (_("  Flags:                             0x%lx%s\n"),
4689               (unsigned long) elf_header.e_flags,
4690               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4691       printf (_("  Size of this header:               %ld (bytes)\n"),
4692               (long) elf_header.e_ehsize);
4693       printf (_("  Size of program headers:           %ld (bytes)\n"),
4694               (long) elf_header.e_phentsize);
4695       printf (_("  Number of program headers:         %ld"),
4696               (long) elf_header.e_phnum);
4697       if (section_headers != NULL
4698           && elf_header.e_phnum == PN_XNUM
4699           && section_headers[0].sh_info != 0)
4700         printf (" (%ld)", (long) section_headers[0].sh_info);
4701       putc ('\n', stdout);
4702       printf (_("  Size of section headers:           %ld (bytes)\n"),
4703               (long) elf_header.e_shentsize);
4704       printf (_("  Number of section headers:         %ld"),
4705               (long) elf_header.e_shnum);
4706       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4707         printf (" (%ld)", (long) section_headers[0].sh_size);
4708       putc ('\n', stdout);
4709       printf (_("  Section header string table index: %ld"),
4710               (long) elf_header.e_shstrndx);
4711       if (section_headers != NULL
4712           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4713         printf (" (%u)", section_headers[0].sh_link);
4714       else if (elf_header.e_shstrndx != SHN_UNDEF
4715                && elf_header.e_shstrndx >= elf_header.e_shnum)
4716         printf (_(" <corrupt: out of range>"));
4717       putc ('\n', stdout);
4718     }
4719
4720   if (section_headers != NULL)
4721     {
4722       if (elf_header.e_phnum == PN_XNUM
4723           && section_headers[0].sh_info != 0)
4724         elf_header.e_phnum = section_headers[0].sh_info;
4725       if (elf_header.e_shnum == SHN_UNDEF)
4726         elf_header.e_shnum = section_headers[0].sh_size;
4727       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4728         elf_header.e_shstrndx = section_headers[0].sh_link;
4729       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4730         elf_header.e_shstrndx = SHN_UNDEF;
4731       free (section_headers);
4732       section_headers = NULL;
4733     }
4734
4735   return TRUE;
4736 }
4737
4738 static bfd_boolean
4739 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4740 {
4741   Elf32_External_Phdr * phdrs;
4742   Elf32_External_Phdr * external;
4743   Elf_Internal_Phdr *   internal;
4744   unsigned int i;
4745   unsigned int size = elf_header.e_phentsize;
4746   unsigned int num  = elf_header.e_phnum;
4747
4748   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4749   if (size == 0 || num == 0)
4750     return FALSE;
4751   if (size < sizeof * phdrs)
4752     {
4753       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4754       return FALSE;
4755     }
4756   if (size > sizeof * phdrs)
4757     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4758
4759   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4760                                             size, num, _("program headers"));
4761   if (phdrs == NULL)
4762     return FALSE;
4763
4764   for (i = 0, internal = pheaders, external = phdrs;
4765        i < elf_header.e_phnum;
4766        i++, internal++, external++)
4767     {
4768       internal->p_type   = BYTE_GET (external->p_type);
4769       internal->p_offset = BYTE_GET (external->p_offset);
4770       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4771       internal->p_paddr  = BYTE_GET (external->p_paddr);
4772       internal->p_filesz = BYTE_GET (external->p_filesz);
4773       internal->p_memsz  = BYTE_GET (external->p_memsz);
4774       internal->p_flags  = BYTE_GET (external->p_flags);
4775       internal->p_align  = BYTE_GET (external->p_align);
4776     }
4777
4778   free (phdrs);
4779   return TRUE;
4780 }
4781
4782 static bfd_boolean
4783 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4784 {
4785   Elf64_External_Phdr * phdrs;
4786   Elf64_External_Phdr * external;
4787   Elf_Internal_Phdr *   internal;
4788   unsigned int i;
4789   unsigned int size = elf_header.e_phentsize;
4790   unsigned int num  = elf_header.e_phnum;
4791
4792   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4793   if (size == 0 || num == 0)
4794     return FALSE;
4795   if (size < sizeof * phdrs)
4796     {
4797       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4798       return FALSE;
4799     }
4800   if (size > sizeof * phdrs)
4801     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4802
4803   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4804                                             size, num, _("program headers"));
4805   if (!phdrs)
4806     return FALSE;
4807
4808   for (i = 0, internal = pheaders, external = phdrs;
4809        i < elf_header.e_phnum;
4810        i++, internal++, external++)
4811     {
4812       internal->p_type   = BYTE_GET (external->p_type);
4813       internal->p_flags  = BYTE_GET (external->p_flags);
4814       internal->p_offset = BYTE_GET (external->p_offset);
4815       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4816       internal->p_paddr  = BYTE_GET (external->p_paddr);
4817       internal->p_filesz = BYTE_GET (external->p_filesz);
4818       internal->p_memsz  = BYTE_GET (external->p_memsz);
4819       internal->p_align  = BYTE_GET (external->p_align);
4820     }
4821
4822   free (phdrs);
4823   return TRUE;
4824 }
4825
4826 /* Returns TRUE if the program headers were read into `program_headers'.  */
4827
4828 static bfd_boolean
4829 get_program_headers (FILE * file)
4830 {
4831   Elf_Internal_Phdr * phdrs;
4832
4833   /* Check cache of prior read.  */
4834   if (program_headers != NULL)
4835     return TRUE;
4836
4837   /* Be kind to memory checkers by looking for
4838      e_phnum values which we know must be invalid.  */
4839   if (elf_header.e_phnum
4840       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4841       >= current_file_size)
4842     {
4843       error (_("Too many program headers - %#x - the file is not that big\n"),
4844              elf_header.e_phnum);
4845       return FALSE;
4846     }
4847
4848   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4849                                          sizeof (Elf_Internal_Phdr));
4850   if (phdrs == NULL)
4851     {
4852       error (_("Out of memory reading %u program headers\n"),
4853              elf_header.e_phnum);
4854       return FALSE;
4855     }
4856
4857   if (is_32bit_elf
4858       ? get_32bit_program_headers (file, phdrs)
4859       : get_64bit_program_headers (file, phdrs))
4860     {
4861       program_headers = phdrs;
4862       return TRUE;
4863     }
4864
4865   free (phdrs);
4866   return FALSE;
4867 }
4868
4869 /* Returns TRUE if the program headers were loaded.  */
4870
4871 static bfd_boolean
4872 process_program_headers (FILE * file)
4873 {
4874   Elf_Internal_Phdr * segment;
4875   unsigned int i;
4876   Elf_Internal_Phdr * previous_load = NULL;
4877
4878   if (elf_header.e_phnum == 0)
4879     {
4880       /* PR binutils/12467.  */
4881       if (elf_header.e_phoff != 0)
4882         {
4883           warn (_("possibly corrupt ELF header - it has a non-zero program"
4884                   " header offset, but no program headers\n"));
4885           return FALSE;
4886         }
4887       else if (do_segments)
4888         printf (_("\nThere are no program headers in this file.\n"));
4889       return TRUE;
4890     }
4891
4892   if (do_segments && !do_header)
4893     {
4894       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4895       printf (_("Entry point "));
4896       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4897       printf (_("\nThere are %d program headers, starting at offset "),
4898               elf_header.e_phnum);
4899       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4900       printf ("\n");
4901     }
4902
4903   if (! get_program_headers (file))
4904     return TRUE;
4905
4906   if (do_segments)
4907     {
4908       if (elf_header.e_phnum > 1)
4909         printf (_("\nProgram Headers:\n"));
4910       else
4911         printf (_("\nProgram Headers:\n"));
4912
4913       if (is_32bit_elf)
4914         printf
4915           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4916       else if (do_wide)
4917         printf
4918           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4919       else
4920         {
4921           printf
4922             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4923           printf
4924             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4925         }
4926     }
4927
4928   dynamic_addr = 0;
4929   dynamic_size = 0;
4930
4931   for (i = 0, segment = program_headers;
4932        i < elf_header.e_phnum;
4933        i++, segment++)
4934     {
4935       if (do_segments)
4936         {
4937           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4938
4939           if (is_32bit_elf)
4940             {
4941               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4942               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4943               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4944               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4945               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4946               printf ("%c%c%c ",
4947                       (segment->p_flags & PF_R ? 'R' : ' '),
4948                       (segment->p_flags & PF_W ? 'W' : ' '),
4949                       (segment->p_flags & PF_X ? 'E' : ' '));
4950               printf ("%#lx", (unsigned long) segment->p_align);
4951             }
4952           else if (do_wide)
4953             {
4954               if ((unsigned long) segment->p_offset == segment->p_offset)
4955                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4956               else
4957                 {
4958                   print_vma (segment->p_offset, FULL_HEX);
4959                   putchar (' ');
4960                 }
4961
4962               print_vma (segment->p_vaddr, FULL_HEX);
4963               putchar (' ');
4964               print_vma (segment->p_paddr, FULL_HEX);
4965               putchar (' ');
4966
4967               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4968                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4969               else
4970                 {
4971                   print_vma (segment->p_filesz, FULL_HEX);
4972                   putchar (' ');
4973                 }
4974
4975               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4976                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4977               else
4978                 {
4979                   print_vma (segment->p_memsz, FULL_HEX);
4980                 }
4981
4982               printf (" %c%c%c ",
4983                       (segment->p_flags & PF_R ? 'R' : ' '),
4984                       (segment->p_flags & PF_W ? 'W' : ' '),
4985                       (segment->p_flags & PF_X ? 'E' : ' '));
4986
4987               if ((unsigned long) segment->p_align == segment->p_align)
4988                 printf ("%#lx", (unsigned long) segment->p_align);
4989               else
4990                 {
4991                   print_vma (segment->p_align, PREFIX_HEX);
4992                 }
4993             }
4994           else
4995             {
4996               print_vma (segment->p_offset, FULL_HEX);
4997               putchar (' ');
4998               print_vma (segment->p_vaddr, FULL_HEX);
4999               putchar (' ');
5000               print_vma (segment->p_paddr, FULL_HEX);
5001               printf ("\n                 ");
5002               print_vma (segment->p_filesz, FULL_HEX);
5003               putchar (' ');
5004               print_vma (segment->p_memsz, FULL_HEX);
5005               printf ("  %c%c%c    ",
5006                       (segment->p_flags & PF_R ? 'R' : ' '),
5007                       (segment->p_flags & PF_W ? 'W' : ' '),
5008                       (segment->p_flags & PF_X ? 'E' : ' '));
5009               print_vma (segment->p_align, PREFIX_HEX);
5010             }
5011
5012           putc ('\n', stdout);
5013         }
5014
5015       switch (segment->p_type)
5016         {
5017         case PT_LOAD:
5018 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5019          required by the ELF standard, several programs, including the Linux
5020          kernel, make use of non-ordered segments.  */
5021           if (previous_load
5022               && previous_load->p_vaddr > segment->p_vaddr)
5023             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5024 #endif
5025           if (segment->p_memsz < segment->p_filesz)
5026             error (_("the segment's file size is larger than its memory size\n"));
5027           previous_load = segment;
5028           break;
5029
5030         case PT_PHDR:
5031           /* PR 20815 - Verify that the program header is loaded into memory.  */
5032           if (i > 0 && previous_load != NULL)
5033             error (_("the PHDR segment must occur before any LOAD segment\n"));
5034           if (elf_header.e_machine != EM_PARISC)
5035             {
5036               unsigned int j;
5037
5038               for (j = 1; j < elf_header.e_phnum; j++)
5039                 if (program_headers[j].p_vaddr <= segment->p_vaddr
5040                     && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5041                     >= (segment->p_vaddr + segment->p_filesz))
5042                   break;
5043               if (j == elf_header.e_phnum)
5044                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5045             }
5046           break;
5047
5048         case PT_DYNAMIC:
5049           if (dynamic_addr)
5050             error (_("more than one dynamic segment\n"));
5051
5052           /* By default, assume that the .dynamic section is the first
5053              section in the DYNAMIC segment.  */
5054           dynamic_addr = segment->p_offset;
5055           dynamic_size = segment->p_filesz;
5056
5057           /* Try to locate the .dynamic section. If there is
5058              a section header table, we can easily locate it.  */
5059           if (section_headers != NULL)
5060             {
5061               Elf_Internal_Shdr * sec;
5062
5063               sec = find_section (".dynamic");
5064               if (sec == NULL || sec->sh_size == 0)
5065                 {
5066                   /* A corresponding .dynamic section is expected, but on
5067                      IA-64/OpenVMS it is OK for it to be missing.  */
5068                   if (!is_ia64_vms ())
5069                     error (_("no .dynamic section in the dynamic segment\n"));
5070                   break;
5071                 }
5072
5073               if (sec->sh_type == SHT_NOBITS)
5074                 {
5075                   dynamic_size = 0;
5076                   break;
5077                 }
5078
5079               dynamic_addr = sec->sh_offset;
5080               dynamic_size = sec->sh_size;
5081
5082               if (dynamic_addr < segment->p_offset
5083                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5084                 warn (_("the .dynamic section is not contained"
5085                         " within the dynamic segment\n"));
5086               else if (dynamic_addr > segment->p_offset)
5087                 warn (_("the .dynamic section is not the first section"
5088                         " in the dynamic segment.\n"));
5089             }
5090
5091           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5092              segment.  Check this after matching against the section headers
5093              so we don't warn on debuginfo file (which have NOBITS .dynamic
5094              sections).  */
5095           if (dynamic_addr + dynamic_size >= current_file_size)
5096             {
5097               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5098               dynamic_addr = dynamic_size = 0;
5099             }
5100           break;
5101
5102         case PT_INTERP:
5103           if (fseek (file, archive_file_offset + (long) segment->p_offset,
5104                      SEEK_SET))
5105             error (_("Unable to find program interpreter name\n"));
5106           else
5107             {
5108               char fmt [32];
5109               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5110
5111               if (ret >= (int) sizeof (fmt) || ret < 0)
5112                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5113
5114               program_interpreter[0] = 0;
5115               if (fscanf (file, fmt, program_interpreter) <= 0)
5116                 error (_("Unable to read program interpreter name\n"));
5117
5118               if (do_segments)
5119                 printf (_("      [Requesting program interpreter: %s]\n"),
5120                     program_interpreter);
5121             }
5122           break;
5123         }
5124     }
5125
5126   if (do_segments && section_headers != NULL && string_table != NULL)
5127     {
5128       printf (_("\n Section to Segment mapping:\n"));
5129       printf (_("  Segment Sections...\n"));
5130
5131       for (i = 0; i < elf_header.e_phnum; i++)
5132         {
5133           unsigned int j;
5134           Elf_Internal_Shdr * section;
5135
5136           segment = program_headers + i;
5137           section = section_headers + 1;
5138
5139           printf ("   %2.2d     ", i);
5140
5141           for (j = 1; j < elf_header.e_shnum; j++, section++)
5142             {
5143               if (!ELF_TBSS_SPECIAL (section, segment)
5144                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5145                 printf ("%s ", printable_section_name (section));
5146             }
5147
5148           putc ('\n',stdout);
5149         }
5150     }
5151
5152   return TRUE;
5153 }
5154
5155
5156 /* Find the file offset corresponding to VMA by using the program headers.  */
5157
5158 static long
5159 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5160 {
5161   Elf_Internal_Phdr * seg;
5162
5163   if (! get_program_headers (file))
5164     {
5165       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5166       return (long) vma;
5167     }
5168
5169   for (seg = program_headers;
5170        seg < program_headers + elf_header.e_phnum;
5171        ++seg)
5172     {
5173       if (seg->p_type != PT_LOAD)
5174         continue;
5175
5176       if (vma >= (seg->p_vaddr & -seg->p_align)
5177           && vma + size <= seg->p_vaddr + seg->p_filesz)
5178         return vma - seg->p_vaddr + seg->p_offset;
5179     }
5180
5181   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5182         (unsigned long) vma);
5183   return (long) vma;
5184 }
5185
5186
5187 /* Allocate memory and load the sections headers into the global pointer
5188    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
5189    generate any error messages if the load fails.  */
5190
5191 static bfd_boolean
5192 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5193 {
5194   Elf32_External_Shdr * shdrs;
5195   Elf_Internal_Shdr *   internal;
5196   unsigned int i;
5197   unsigned int size = elf_header.e_shentsize;
5198   unsigned int num = probe ? 1 : elf_header.e_shnum;
5199
5200   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5201   if (size == 0 || num == 0)
5202     return FALSE;
5203   if (size < sizeof * shdrs)
5204     {
5205       if (! probe)
5206         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5207       return FALSE;
5208     }
5209   if (!probe && size > sizeof * shdrs)
5210     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5211
5212   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5213                                             size, num,
5214                                             probe ? NULL : _("section headers"));
5215   if (shdrs == NULL)
5216     return FALSE;
5217
5218   if (section_headers != NULL)
5219     free (section_headers);
5220   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5221                                                    sizeof (Elf_Internal_Shdr));
5222   if (section_headers == NULL)
5223     {
5224       if (!probe)
5225         error (_("Out of memory reading %u section headers\n"), num);
5226       return FALSE;
5227     }
5228
5229   for (i = 0, internal = section_headers;
5230        i < num;
5231        i++, internal++)
5232     {
5233       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5234       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5235       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5236       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5237       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5238       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5239       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5240       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5241       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5242       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5243       if (!probe && internal->sh_link > num)
5244         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5245       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5246         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5247     }
5248
5249   free (shdrs);
5250   return TRUE;
5251 }
5252
5253 static bfd_boolean
5254 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5255 {
5256   Elf64_External_Shdr * shdrs;
5257   Elf_Internal_Shdr *   internal;
5258   unsigned int i;
5259   unsigned int size = elf_header.e_shentsize;
5260   unsigned int num = probe ? 1 : elf_header.e_shnum;
5261
5262   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5263   if (size == 0 || num == 0)
5264     return FALSE;
5265   if (size < sizeof * shdrs)
5266     {
5267       if (! probe)
5268         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5269       return FALSE;
5270     }
5271   if (! probe && size > sizeof * shdrs)
5272     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5273
5274   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5275                                             size, num,
5276                                             probe ? NULL : _("section headers"));
5277   if (shdrs == NULL)
5278     return FALSE;
5279
5280   if (section_headers != NULL)
5281     free (section_headers);
5282   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5283                                                    sizeof (Elf_Internal_Shdr));
5284   if (section_headers == NULL)
5285     {
5286       if (! probe)
5287         error (_("Out of memory reading %u section headers\n"), num);
5288       return FALSE;
5289     }
5290
5291   for (i = 0, internal = section_headers;
5292        i < num;
5293        i++, internal++)
5294     {
5295       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5296       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5297       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5298       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5299       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5300       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5301       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5302       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5303       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5304       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5305       if (!probe && internal->sh_link > num)
5306         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5307       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5308         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5309     }
5310
5311   free (shdrs);
5312   return TRUE;
5313 }
5314
5315 static Elf_Internal_Sym *
5316 get_32bit_elf_symbols (FILE * file,
5317                        Elf_Internal_Shdr * section,
5318                        unsigned long * num_syms_return)
5319 {
5320   unsigned long number = 0;
5321   Elf32_External_Sym * esyms = NULL;
5322   Elf_External_Sym_Shndx * shndx = NULL;
5323   Elf_Internal_Sym * isyms = NULL;
5324   Elf_Internal_Sym * psym;
5325   unsigned int j;
5326
5327   if (section->sh_size == 0)
5328     {
5329       if (num_syms_return != NULL)
5330         * num_syms_return = 0;
5331       return NULL;
5332     }
5333
5334   /* Run some sanity checks first.  */
5335   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5336     {
5337       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5338              printable_section_name (section), (unsigned long) section->sh_entsize);
5339       goto exit_point;
5340     }
5341
5342   if (section->sh_size > current_file_size)
5343     {
5344       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5345              printable_section_name (section), (unsigned long) section->sh_size);
5346       goto exit_point;
5347     }
5348
5349   number = section->sh_size / section->sh_entsize;
5350
5351   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5352     {
5353       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5354              (unsigned long) section->sh_size,
5355              printable_section_name (section),
5356              (unsigned long) section->sh_entsize);
5357       goto exit_point;
5358     }
5359
5360   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5361                                            section->sh_size, _("symbols"));
5362   if (esyms == NULL)
5363     goto exit_point;
5364
5365   {
5366     elf_section_list * entry;
5367
5368     shndx = NULL;
5369     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5370       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5371         {
5372           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5373                                                        entry->hdr->sh_offset,
5374                                                        1, entry->hdr->sh_size,
5375                                                        _("symbol table section indicies"));
5376           if (shndx == NULL)
5377             goto exit_point;
5378           /* PR17531: file: heap-buffer-overflow */
5379           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5380             {
5381               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5382                      printable_section_name (entry->hdr),
5383                      (unsigned long) entry->hdr->sh_size,
5384                      (unsigned long) section->sh_size);
5385               goto exit_point;
5386             }
5387         }
5388   }
5389
5390   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5391
5392   if (isyms == NULL)
5393     {
5394       error (_("Out of memory reading %lu symbols\n"),
5395              (unsigned long) number);
5396       goto exit_point;
5397     }
5398
5399   for (j = 0, psym = isyms; j < number; j++, psym++)
5400     {
5401       psym->st_name  = BYTE_GET (esyms[j].st_name);
5402       psym->st_value = BYTE_GET (esyms[j].st_value);
5403       psym->st_size  = BYTE_GET (esyms[j].st_size);
5404       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5405       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5406         psym->st_shndx
5407           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5408       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5409         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5410       psym->st_info  = BYTE_GET (esyms[j].st_info);
5411       psym->st_other = BYTE_GET (esyms[j].st_other);
5412     }
5413
5414  exit_point:
5415   if (shndx != NULL)
5416     free (shndx);
5417   if (esyms != NULL)
5418     free (esyms);
5419
5420   if (num_syms_return != NULL)
5421     * num_syms_return = isyms == NULL ? 0 : number;
5422
5423   return isyms;
5424 }
5425
5426 static Elf_Internal_Sym *
5427 get_64bit_elf_symbols (FILE * file,
5428                        Elf_Internal_Shdr * section,
5429                        unsigned long * num_syms_return)
5430 {
5431   unsigned long number = 0;
5432   Elf64_External_Sym * esyms = NULL;
5433   Elf_External_Sym_Shndx * shndx = NULL;
5434   Elf_Internal_Sym * isyms = NULL;
5435   Elf_Internal_Sym * psym;
5436   unsigned int j;
5437
5438   if (section->sh_size == 0)
5439     {
5440       if (num_syms_return != NULL)
5441         * num_syms_return = 0;
5442       return NULL;
5443     }
5444
5445   /* Run some sanity checks first.  */
5446   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5447     {
5448       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449              printable_section_name (section),
5450              (unsigned long) section->sh_entsize);
5451       goto exit_point;
5452     }
5453
5454   if (section->sh_size > current_file_size)
5455     {
5456       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457              printable_section_name (section),
5458              (unsigned long) section->sh_size);
5459       goto exit_point;
5460     }
5461
5462   number = section->sh_size / section->sh_entsize;
5463
5464   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5465     {
5466       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467              (unsigned long) section->sh_size,
5468              printable_section_name (section),
5469              (unsigned long) section->sh_entsize);
5470       goto exit_point;
5471     }
5472
5473   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5474                                            section->sh_size, _("symbols"));
5475   if (!esyms)
5476     goto exit_point;
5477
5478   {
5479     elf_section_list * entry;
5480
5481     shndx = NULL;
5482     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5483       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5484         {
5485           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5486                                                        entry->hdr->sh_offset,
5487                                                        1, entry->hdr->sh_size,
5488                                                        _("symbol table section indicies"));
5489           if (shndx == NULL)
5490             goto exit_point;
5491           /* PR17531: file: heap-buffer-overflow */
5492           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5493             {
5494               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495                      printable_section_name (entry->hdr),
5496                      (unsigned long) entry->hdr->sh_size,
5497                      (unsigned long) section->sh_size);
5498               goto exit_point;
5499             }
5500         }
5501   }
5502
5503   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5504
5505   if (isyms == NULL)
5506     {
5507       error (_("Out of memory reading %lu symbols\n"),
5508              (unsigned long) number);
5509       goto exit_point;
5510     }
5511
5512   for (j = 0, psym = isyms; j < number; j++, psym++)
5513     {
5514       psym->st_name  = BYTE_GET (esyms[j].st_name);
5515       psym->st_info  = BYTE_GET (esyms[j].st_info);
5516       psym->st_other = BYTE_GET (esyms[j].st_other);
5517       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5518
5519       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5520         psym->st_shndx
5521           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5522       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5523         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5524
5525       psym->st_value = BYTE_GET (esyms[j].st_value);
5526       psym->st_size  = BYTE_GET (esyms[j].st_size);
5527     }
5528
5529  exit_point:
5530   if (shndx != NULL)
5531     free (shndx);
5532   if (esyms != NULL)
5533     free (esyms);
5534
5535   if (num_syms_return != NULL)
5536     * num_syms_return = isyms == NULL ? 0 : number;
5537
5538   return isyms;
5539 }
5540
5541 static const char *
5542 get_elf_section_flags (bfd_vma sh_flags)
5543 {
5544   static char buff[1024];
5545   char * p = buff;
5546   unsigned int field_size = is_32bit_elf ? 8 : 16;
5547   signed int sindex;
5548   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5549   bfd_vma os_flags = 0;
5550   bfd_vma proc_flags = 0;
5551   bfd_vma unknown_flags = 0;
5552   static const struct
5553     {
5554       const char * str;
5555       unsigned int len;
5556     }
5557   flags [] =
5558     {
5559       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5560       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5561       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5562       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5563       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5564       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5565       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5566       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5567       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5568       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5569       /* IA-64 specific.  */
5570       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5571       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5572       /* IA-64 OpenVMS specific.  */
5573       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5574       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5575       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5576       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5577       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5578       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5579       /* Generic.  */
5580       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5581       /* SPARC specific.  */
5582       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5583       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5584       /* ARM specific.  */
5585       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5586       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5587       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5588       /* GNU specific.  */
5589       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5590     };
5591
5592   if (do_section_details)
5593     {
5594       sprintf (buff, "[%*.*lx]: ",
5595                field_size, field_size, (unsigned long) sh_flags);
5596       p += field_size + 4;
5597     }
5598
5599   while (sh_flags)
5600     {
5601       bfd_vma flag;
5602
5603       flag = sh_flags & - sh_flags;
5604       sh_flags &= ~ flag;
5605
5606       if (do_section_details)
5607         {
5608           switch (flag)
5609             {
5610             case SHF_WRITE:             sindex = 0; break;
5611             case SHF_ALLOC:             sindex = 1; break;
5612             case SHF_EXECINSTR:         sindex = 2; break;
5613             case SHF_MERGE:             sindex = 3; break;
5614             case SHF_STRINGS:           sindex = 4; break;
5615             case SHF_INFO_LINK:         sindex = 5; break;
5616             case SHF_LINK_ORDER:        sindex = 6; break;
5617             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5618             case SHF_GROUP:             sindex = 8; break;
5619             case SHF_TLS:               sindex = 9; break;
5620             case SHF_EXCLUDE:           sindex = 18; break;
5621             case SHF_COMPRESSED:        sindex = 20; break;
5622             case SHF_GNU_MBIND:         sindex = 24; break;
5623
5624             default:
5625               sindex = -1;
5626               switch (elf_header.e_machine)
5627                 {
5628                 case EM_IA_64:
5629                   if (flag == SHF_IA_64_SHORT)
5630                     sindex = 10;
5631                   else if (flag == SHF_IA_64_NORECOV)
5632                     sindex = 11;
5633 #ifdef BFD64
5634                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5635                     switch (flag)
5636                       {
5637                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5638                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5639                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5640                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5641                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5642                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5643                       default:                        break;
5644                       }
5645 #endif
5646                   break;
5647
5648                 case EM_386:
5649                 case EM_IAMCU:
5650                 case EM_X86_64:
5651                 case EM_L1OM:
5652                 case EM_K1OM:
5653                 case EM_OLD_SPARCV9:
5654                 case EM_SPARC32PLUS:
5655                 case EM_SPARCV9:
5656                 case EM_SPARC:
5657                   if (flag == SHF_ORDERED)
5658                     sindex = 19;
5659                   break;
5660
5661                 case EM_ARM:
5662                   switch (flag)
5663                     {
5664                     case SHF_ENTRYSECT: sindex = 21; break;
5665                     case SHF_ARM_PURECODE: sindex = 22; break;
5666                     case SHF_COMDEF: sindex = 23; break;
5667                     default: break;
5668                     }
5669                   break;
5670
5671                 default:
5672                   break;
5673                 }
5674             }
5675
5676           if (sindex != -1)
5677             {
5678               if (p != buff + field_size + 4)
5679                 {
5680                   if (size < (10 + 2))
5681                     {
5682                       warn (_("Internal error: not enough buffer room for section flag info"));
5683                       return _("<unknown>");
5684                     }
5685                   size -= 2;
5686                   *p++ = ',';
5687                   *p++ = ' ';
5688                 }
5689
5690               size -= flags [sindex].len;
5691               p = stpcpy (p, flags [sindex].str);
5692             }
5693           else if (flag & SHF_MASKOS)
5694             os_flags |= flag;
5695           else if (flag & SHF_MASKPROC)
5696             proc_flags |= flag;
5697           else
5698             unknown_flags |= flag;
5699         }
5700       else
5701         {
5702           switch (flag)
5703             {
5704             case SHF_WRITE:             *p = 'W'; break;
5705             case SHF_ALLOC:             *p = 'A'; break;
5706             case SHF_EXECINSTR:         *p = 'X'; break;
5707             case SHF_MERGE:             *p = 'M'; break;
5708             case SHF_STRINGS:           *p = 'S'; break;
5709             case SHF_INFO_LINK:         *p = 'I'; break;
5710             case SHF_LINK_ORDER:        *p = 'L'; break;
5711             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5712             case SHF_GROUP:             *p = 'G'; break;
5713             case SHF_TLS:               *p = 'T'; break;
5714             case SHF_EXCLUDE:           *p = 'E'; break;
5715             case SHF_COMPRESSED:        *p = 'C'; break;
5716             case SHF_GNU_MBIND:         *p = 'D'; break;
5717
5718             default:
5719               if ((elf_header.e_machine == EM_X86_64
5720                    || elf_header.e_machine == EM_L1OM
5721                    || elf_header.e_machine == EM_K1OM)
5722                   && flag == SHF_X86_64_LARGE)
5723                 *p = 'l';
5724               else if (elf_header.e_machine == EM_ARM
5725                        && flag == SHF_ARM_PURECODE)
5726                   *p = 'y';
5727               else if (flag & SHF_MASKOS)
5728                 {
5729                   *p = 'o';
5730                   sh_flags &= ~ SHF_MASKOS;
5731                 }
5732               else if (flag & SHF_MASKPROC)
5733                 {
5734                   *p = 'p';
5735                   sh_flags &= ~ SHF_MASKPROC;
5736                 }
5737               else
5738                 *p = 'x';
5739               break;
5740             }
5741           p++;
5742         }
5743     }
5744
5745   if (do_section_details)
5746     {
5747       if (os_flags)
5748         {
5749           size -= 5 + field_size;
5750           if (p != buff + field_size + 4)
5751             {
5752               if (size < (2 + 1))
5753                 {
5754                   warn (_("Internal error: not enough buffer room for section flag info"));
5755                   return _("<unknown>");
5756                 }
5757               size -= 2;
5758               *p++ = ',';
5759               *p++ = ' ';
5760             }
5761           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5762                    (unsigned long) os_flags);
5763           p += 5 + field_size;
5764         }
5765       if (proc_flags)
5766         {
5767           size -= 7 + field_size;
5768           if (p != buff + field_size + 4)
5769             {
5770               if (size < (2 + 1))
5771                 {
5772                   warn (_("Internal error: not enough buffer room for section flag info"));
5773                   return _("<unknown>");
5774                 }
5775               size -= 2;
5776               *p++ = ',';
5777               *p++ = ' ';
5778             }
5779           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5780                    (unsigned long) proc_flags);
5781           p += 7 + field_size;
5782         }
5783       if (unknown_flags)
5784         {
5785           size -= 10 + field_size;
5786           if (p != buff + field_size + 4)
5787             {
5788               if (size < (2 + 1))
5789                 {
5790                   warn (_("Internal error: not enough buffer room for section flag info"));
5791                   return _("<unknown>");
5792                 }
5793               size -= 2;
5794               *p++ = ',';
5795               *p++ = ' ';
5796             }
5797           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5798                    (unsigned long) unknown_flags);
5799           p += 10 + field_size;
5800         }
5801     }
5802
5803   *p = '\0';
5804   return buff;
5805 }
5806
5807 static unsigned int
5808 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5809 {
5810   if (is_32bit_elf)
5811     {
5812       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5813
5814       if (size < sizeof (* echdr))
5815         {
5816           error (_("Compressed section is too small even for a compression header\n"));
5817           return 0;
5818         }
5819
5820       chdr->ch_type = BYTE_GET (echdr->ch_type);
5821       chdr->ch_size = BYTE_GET (echdr->ch_size);
5822       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5823       return sizeof (*echdr);
5824     }
5825   else
5826     {
5827       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5828
5829       if (size < sizeof (* echdr))
5830         {
5831           error (_("Compressed section is too small even for a compression header\n"));
5832           return 0;
5833         }
5834
5835       chdr->ch_type = BYTE_GET (echdr->ch_type);
5836       chdr->ch_size = BYTE_GET (echdr->ch_size);
5837       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5838       return sizeof (*echdr);
5839     }
5840 }
5841
5842 static bfd_boolean
5843 process_section_headers (FILE * file)
5844 {
5845   Elf_Internal_Shdr * section;
5846   unsigned int i;
5847
5848   section_headers = NULL;
5849
5850   if (elf_header.e_shnum == 0)
5851     {
5852       /* PR binutils/12467.  */
5853       if (elf_header.e_shoff != 0)
5854         {
5855           warn (_("possibly corrupt ELF file header - it has a non-zero"
5856                   " section header offset, but no section headers\n"));
5857           return FALSE;
5858         }
5859       else if (do_sections)
5860         printf (_("\nThere are no sections in this file.\n"));
5861
5862       return TRUE;
5863     }
5864
5865   if (do_sections && !do_header)
5866     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5867             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5868
5869   if (is_32bit_elf)
5870     {
5871       if (! get_32bit_section_headers (file, FALSE))
5872         return FALSE;
5873     }
5874   else
5875     {
5876       if (! get_64bit_section_headers (file, FALSE))
5877         return FALSE;
5878     }
5879
5880   /* Read in the string table, so that we have names to display.  */
5881   if (elf_header.e_shstrndx != SHN_UNDEF
5882        && elf_header.e_shstrndx < elf_header.e_shnum)
5883     {
5884       section = section_headers + elf_header.e_shstrndx;
5885
5886       if (section->sh_size != 0)
5887         {
5888           string_table = (char *) get_data (NULL, file, section->sh_offset,
5889                                             1, section->sh_size,
5890                                             _("string table"));
5891
5892           string_table_length = string_table != NULL ? section->sh_size : 0;
5893         }
5894     }
5895
5896   /* Scan the sections for the dynamic symbol table
5897      and dynamic string table and debug sections.  */
5898   dynamic_symbols = NULL;
5899   dynamic_strings = NULL;
5900   dynamic_syminfo = NULL;
5901   symtab_shndx_list = NULL;
5902
5903   eh_addr_size = is_32bit_elf ? 4 : 8;
5904   switch (elf_header.e_machine)
5905     {
5906     case EM_MIPS:
5907     case EM_MIPS_RS3_LE:
5908       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5909          FDE addresses.  However, the ABI also has a semi-official ILP32
5910          variant for which the normal FDE address size rules apply.
5911
5912          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5913          section, where XX is the size of longs in bits.  Unfortunately,
5914          earlier compilers provided no way of distinguishing ILP32 objects
5915          from LP64 objects, so if there's any doubt, we should assume that
5916          the official LP64 form is being used.  */
5917       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5918           && find_section (".gcc_compiled_long32") == NULL)
5919         eh_addr_size = 8;
5920       break;
5921
5922     case EM_H8_300:
5923     case EM_H8_300H:
5924       switch (elf_header.e_flags & EF_H8_MACH)
5925         {
5926         case E_H8_MACH_H8300:
5927         case E_H8_MACH_H8300HN:
5928         case E_H8_MACH_H8300SN:
5929         case E_H8_MACH_H8300SXN:
5930           eh_addr_size = 2;
5931           break;
5932         case E_H8_MACH_H8300H:
5933         case E_H8_MACH_H8300S:
5934         case E_H8_MACH_H8300SX:
5935           eh_addr_size = 4;
5936           break;
5937         }
5938       break;
5939
5940     case EM_M32C_OLD:
5941     case EM_M32C:
5942       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5943         {
5944         case EF_M32C_CPU_M16C:
5945           eh_addr_size = 2;
5946           break;
5947         }
5948       break;
5949     }
5950
5951 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5952   do                                                                    \
5953     {                                                                   \
5954       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5955       if (section->sh_entsize != expected_entsize)                      \
5956         {                                                               \
5957           char buf[40];                                                 \
5958           sprintf_vma (buf, section->sh_entsize);                       \
5959           /* Note: coded this way so that there is a single string for  \
5960              translation.  */ \
5961           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5962           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5963                    (unsigned) expected_entsize);                        \
5964           section->sh_entsize = expected_entsize;                       \
5965         }                                                               \
5966     }                                                                   \
5967   while (0)
5968
5969 #define CHECK_ENTSIZE(section, i, type)                                 \
5970   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5971                         sizeof (Elf64_External_##type))
5972
5973   for (i = 0, section = section_headers;
5974        i < elf_header.e_shnum;
5975        i++, section++)
5976     {
5977       char * name = SECTION_NAME (section);
5978
5979       if (section->sh_type == SHT_DYNSYM)
5980         {
5981           if (dynamic_symbols != NULL)
5982             {
5983               error (_("File contains multiple dynamic symbol tables\n"));
5984               continue;
5985             }
5986
5987           CHECK_ENTSIZE (section, i, Sym);
5988           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5989         }
5990       else if (section->sh_type == SHT_STRTAB
5991                && streq (name, ".dynstr"))
5992         {
5993           if (dynamic_strings != NULL)
5994             {
5995               error (_("File contains multiple dynamic string tables\n"));
5996               continue;
5997             }
5998
5999           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
6000                                                1, section->sh_size,
6001                                                _("dynamic strings"));
6002           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6003         }
6004       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6005         {
6006           elf_section_list * entry = xmalloc (sizeof * entry);
6007           entry->hdr = section;
6008           entry->next = symtab_shndx_list;
6009           symtab_shndx_list = entry;
6010         }
6011       else if (section->sh_type == SHT_SYMTAB)
6012         CHECK_ENTSIZE (section, i, Sym);
6013       else if (section->sh_type == SHT_GROUP)
6014         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6015       else if (section->sh_type == SHT_REL)
6016         CHECK_ENTSIZE (section, i, Rel);
6017       else if (section->sh_type == SHT_RELA)
6018         CHECK_ENTSIZE (section, i, Rela);
6019       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6020                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6021                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6022                 || do_debug_str || do_debug_loc || do_debug_ranges
6023                 || do_debug_addr || do_debug_cu_index)
6024                && (const_strneq (name, ".debug_")
6025                    || const_strneq (name, ".zdebug_")))
6026         {
6027           if (name[1] == 'z')
6028             name += sizeof (".zdebug_") - 1;
6029           else
6030             name += sizeof (".debug_") - 1;
6031
6032           if (do_debugging
6033               || (do_debug_info     && const_strneq (name, "info"))
6034               || (do_debug_info     && const_strneq (name, "types"))
6035               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6036               || (do_debug_lines    && strcmp (name, "line") == 0)
6037               || (do_debug_lines    && const_strneq (name, "line."))
6038               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6039               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6040               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6041               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6042               || (do_debug_aranges  && const_strneq (name, "aranges"))
6043               || (do_debug_ranges   && const_strneq (name, "ranges"))
6044               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6045               || (do_debug_frames   && const_strneq (name, "frame"))
6046               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6047               || (do_debug_macinfo  && const_strneq (name, "macro"))
6048               || (do_debug_str      && const_strneq (name, "str"))
6049               || (do_debug_loc      && const_strneq (name, "loc"))
6050               || (do_debug_loc      && const_strneq (name, "loclists"))
6051               || (do_debug_addr     && const_strneq (name, "addr"))
6052               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6053               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6054               )
6055             request_dump_bynumber (i, DEBUG_DUMP);
6056         }
6057       /* Linkonce section to be combined with .debug_info at link time.  */
6058       else if ((do_debugging || do_debug_info)
6059                && const_strneq (name, ".gnu.linkonce.wi."))
6060         request_dump_bynumber (i, DEBUG_DUMP);
6061       else if (do_debug_frames && streq (name, ".eh_frame"))
6062         request_dump_bynumber (i, DEBUG_DUMP);
6063       else if (do_gdb_index && (streq (name, ".gdb_index")
6064                                 || streq (name, ".debug_names")))
6065         request_dump_bynumber (i, DEBUG_DUMP);
6066       /* Trace sections for Itanium VMS.  */
6067       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6068                 || do_trace_aranges)
6069                && const_strneq (name, ".trace_"))
6070         {
6071           name += sizeof (".trace_") - 1;
6072
6073           if (do_debugging
6074               || (do_trace_info     && streq (name, "info"))
6075               || (do_trace_abbrevs  && streq (name, "abbrev"))
6076               || (do_trace_aranges  && streq (name, "aranges"))
6077               )
6078             request_dump_bynumber (i, DEBUG_DUMP);
6079         }
6080     }
6081
6082   if (! do_sections)
6083     return TRUE;
6084
6085   if (elf_header.e_shnum > 1)
6086     printf (_("\nSection Headers:\n"));
6087   else
6088     printf (_("\nSection Header:\n"));
6089
6090   if (is_32bit_elf)
6091     {
6092       if (do_section_details)
6093         {
6094           printf (_("  [Nr] Name\n"));
6095           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6096         }
6097       else
6098         printf
6099           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6100     }
6101   else if (do_wide)
6102     {
6103       if (do_section_details)
6104         {
6105           printf (_("  [Nr] Name\n"));
6106           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6107         }
6108       else
6109         printf
6110           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6111     }
6112   else
6113     {
6114       if (do_section_details)
6115         {
6116           printf (_("  [Nr] Name\n"));
6117           printf (_("       Type              Address          Offset            Link\n"));
6118           printf (_("       Size              EntSize          Info              Align\n"));
6119         }
6120       else
6121         {
6122           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6123           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6124         }
6125     }
6126
6127   if (do_section_details)
6128     printf (_("       Flags\n"));
6129
6130   for (i = 0, section = section_headers;
6131        i < elf_header.e_shnum;
6132        i++, section++)
6133     {
6134       /* Run some sanity checks on the section header.  */
6135
6136       /* Check the sh_link field.  */
6137       switch (section->sh_type)
6138         {
6139         case SHT_SYMTAB_SHNDX:
6140         case SHT_GROUP:
6141         case SHT_HASH:
6142         case SHT_GNU_HASH:
6143         case SHT_GNU_versym:
6144         case SHT_REL:
6145         case SHT_RELA:
6146           if (section->sh_link < 1
6147               || section->sh_link >= elf_header.e_shnum
6148               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6149                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6150             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6151                   i, section->sh_link);
6152           break;
6153
6154         case SHT_DYNAMIC:
6155         case SHT_SYMTAB:
6156         case SHT_DYNSYM:
6157         case SHT_GNU_verneed:
6158         case SHT_GNU_verdef:
6159         case SHT_GNU_LIBLIST:
6160           if (section->sh_link < 1
6161               || section->sh_link >= elf_header.e_shnum
6162               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6163             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6164                   i, section->sh_link);
6165           break;
6166
6167         case SHT_INIT_ARRAY:
6168         case SHT_FINI_ARRAY:
6169         case SHT_PREINIT_ARRAY:
6170           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6171             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6172                   i, section->sh_link);
6173           break;
6174
6175         default:
6176           /* FIXME: Add support for target specific section types.  */
6177 #if 0     /* Currently we do not check other section types as there are too
6178              many special cases.  Stab sections for example have a type
6179              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6180              section.  */
6181           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6182             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6183                   i, section->sh_link);
6184 #endif
6185           break;
6186         }
6187
6188       /* Check the sh_info field.  */
6189       switch (section->sh_type)
6190         {
6191         case SHT_REL:
6192         case SHT_RELA:
6193           if (section->sh_info < 1
6194               || section->sh_info >= elf_header.e_shnum
6195               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6196                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6197                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6198                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6199                   /* FIXME: Are other section types valid ?  */
6200                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6201             {
6202               if (section->sh_info == 0
6203                   && (streq (SECTION_NAME (section), ".rel.dyn")
6204                       || streq (SECTION_NAME (section), ".rela.dyn")))
6205                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6206                    of zero.  The relocations in these sections may apply
6207                    to many different sections.  */
6208                    ;
6209               else
6210                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6211                       i, section->sh_info);
6212             }
6213           break;
6214
6215         case SHT_DYNAMIC:
6216         case SHT_HASH:
6217         case SHT_SYMTAB_SHNDX:
6218         case SHT_INIT_ARRAY:
6219         case SHT_FINI_ARRAY:
6220         case SHT_PREINIT_ARRAY:
6221           if (section->sh_info != 0)
6222             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6223                   i, section->sh_info);
6224           break;
6225
6226         case SHT_GROUP:
6227         case SHT_SYMTAB:
6228         case SHT_DYNSYM:
6229           /* A symbol index - we assume that it is valid.  */
6230           break;
6231
6232         default:
6233           /* FIXME: Add support for target specific section types.  */
6234           if (section->sh_type == SHT_NOBITS)
6235             /* NOBITS section headers with non-zero sh_info fields can be
6236                created when a binary is stripped of everything but its debug
6237                information.  The stripped sections have their headers
6238                preserved but their types set to SHT_NOBITS.  So do not check
6239                this type of section.  */
6240             ;
6241           else if (section->sh_flags & SHF_INFO_LINK)
6242             {
6243               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6244                 warn (_("[%2u]: Expected link to another section in info field"), i);
6245             }
6246           else if (section->sh_type < SHT_LOOS
6247                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6248                    && section->sh_info != 0)
6249             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6250                   i, section->sh_info);
6251           break;
6252         }
6253
6254       /* Check the sh_size field.  */
6255       if (section->sh_size > current_file_size
6256           && section->sh_type != SHT_NOBITS
6257           && section->sh_type != SHT_NULL
6258           && section->sh_type < SHT_LOOS)
6259         warn (_("Size of section %u is larger than the entire file!\n"), i);
6260
6261       printf ("  [%2u] ", i);
6262       if (do_section_details)
6263         printf ("%s\n      ", printable_section_name (section));
6264       else
6265         print_symbol (-17, SECTION_NAME (section));
6266
6267       printf (do_wide ? " %-15s " : " %-15.15s ",
6268               get_section_type_name (section->sh_type));
6269
6270       if (is_32bit_elf)
6271         {
6272           const char * link_too_big = NULL;
6273
6274           print_vma (section->sh_addr, LONG_HEX);
6275
6276           printf ( " %6.6lx %6.6lx %2.2lx",
6277                    (unsigned long) section->sh_offset,
6278                    (unsigned long) section->sh_size,
6279                    (unsigned long) section->sh_entsize);
6280
6281           if (do_section_details)
6282             fputs ("  ", stdout);
6283           else
6284             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6285
6286           if (section->sh_link >= elf_header.e_shnum)
6287             {
6288               link_too_big = "";
6289               /* The sh_link value is out of range.  Normally this indicates
6290                  an error but it can have special values in Solaris binaries.  */
6291               switch (elf_header.e_machine)
6292                 {
6293                 case EM_386:
6294                 case EM_IAMCU:
6295                 case EM_X86_64:
6296                 case EM_L1OM:
6297                 case EM_K1OM:
6298                 case EM_OLD_SPARCV9:
6299                 case EM_SPARC32PLUS:
6300                 case EM_SPARCV9:
6301                 case EM_SPARC:
6302                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6303                     link_too_big = "BEFORE";
6304                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6305                     link_too_big = "AFTER";
6306                   break;
6307                 default:
6308                   break;
6309                 }
6310             }
6311
6312           if (do_section_details)
6313             {
6314               if (link_too_big != NULL && * link_too_big)
6315                 printf ("<%s> ", link_too_big);
6316               else
6317                 printf ("%2u ", section->sh_link);
6318               printf ("%3u %2lu\n", section->sh_info,
6319                       (unsigned long) section->sh_addralign);
6320             }
6321           else
6322             printf ("%2u %3u %2lu\n",
6323                     section->sh_link,
6324                     section->sh_info,
6325                     (unsigned long) section->sh_addralign);
6326
6327           if (link_too_big && ! * link_too_big)
6328             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6329                   i, section->sh_link);
6330         }
6331       else if (do_wide)
6332         {
6333           print_vma (section->sh_addr, LONG_HEX);
6334
6335           if ((long) section->sh_offset == section->sh_offset)
6336             printf (" %6.6lx", (unsigned long) section->sh_offset);
6337           else
6338             {
6339               putchar (' ');
6340               print_vma (section->sh_offset, LONG_HEX);
6341             }
6342
6343           if ((unsigned long) section->sh_size == section->sh_size)
6344             printf (" %6.6lx", (unsigned long) section->sh_size);
6345           else
6346             {
6347               putchar (' ');
6348               print_vma (section->sh_size, LONG_HEX);
6349             }
6350
6351           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6352             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6353           else
6354             {
6355               putchar (' ');
6356               print_vma (section->sh_entsize, LONG_HEX);
6357             }
6358
6359           if (do_section_details)
6360             fputs ("  ", stdout);
6361           else
6362             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6363
6364           printf ("%2u %3u ", section->sh_link, section->sh_info);
6365
6366           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6367             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6368           else
6369             {
6370               print_vma (section->sh_addralign, DEC);
6371               putchar ('\n');
6372             }
6373         }
6374       else if (do_section_details)
6375         {
6376           printf ("       %-15.15s  ",
6377                   get_section_type_name (section->sh_type));
6378           print_vma (section->sh_addr, LONG_HEX);
6379           if ((long) section->sh_offset == section->sh_offset)
6380             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6381           else
6382             {
6383               printf ("  ");
6384               print_vma (section->sh_offset, LONG_HEX);
6385             }
6386           printf ("  %u\n       ", section->sh_link);
6387           print_vma (section->sh_size, LONG_HEX);
6388           putchar (' ');
6389           print_vma (section->sh_entsize, LONG_HEX);
6390
6391           printf ("  %-16u  %lu\n",
6392                   section->sh_info,
6393                   (unsigned long) section->sh_addralign);
6394         }
6395       else
6396         {
6397           putchar (' ');
6398           print_vma (section->sh_addr, LONG_HEX);
6399           if ((long) section->sh_offset == section->sh_offset)
6400             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6401           else
6402             {
6403               printf ("  ");
6404               print_vma (section->sh_offset, LONG_HEX);
6405             }
6406           printf ("\n       ");
6407           print_vma (section->sh_size, LONG_HEX);
6408           printf ("  ");
6409           print_vma (section->sh_entsize, LONG_HEX);
6410
6411           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6412
6413           printf ("     %2u   %3u     %lu\n",
6414                   section->sh_link,
6415                   section->sh_info,
6416                   (unsigned long) section->sh_addralign);
6417         }
6418
6419       if (do_section_details)
6420         {
6421           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6422           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6423             {
6424               /* Minimum section size is 12 bytes for 32-bit compression
6425                  header + 12 bytes for compressed data header.  */
6426               unsigned char buf[24];
6427
6428               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6429               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6430                             sizeof (buf), _("compression header")))
6431                 {
6432                   Elf_Internal_Chdr chdr;
6433
6434                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6435
6436                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6437                     printf ("       ZLIB, ");
6438                   else
6439                     printf (_("       [<unknown>: 0x%x], "),
6440                             chdr.ch_type);
6441                   print_vma (chdr.ch_size, LONG_HEX);
6442                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6443                 }
6444             }
6445         }
6446     }
6447
6448   if (!do_section_details)
6449     {
6450       /* The ordering of the letters shown here matches the ordering of the
6451          corresponding SHF_xxx values, and hence the order in which these
6452          letters will be displayed to the user.  */
6453       printf (_("Key to Flags:\n\
6454   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6455   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6456   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6457       if (elf_header.e_machine == EM_X86_64
6458           || elf_header.e_machine == EM_L1OM
6459           || elf_header.e_machine == EM_K1OM)
6460         printf (_("l (large), "));
6461       else if (elf_header.e_machine == EM_ARM)
6462         printf (_("y (purecode), "));
6463       printf ("p (processor specific)\n");
6464     }
6465
6466   return TRUE;
6467 }
6468
6469 static const char *
6470 get_group_flags (unsigned int flags)
6471 {
6472   static char buff[128];
6473
6474   if (flags == 0)
6475     return "";
6476   else if (flags == GRP_COMDAT)
6477     return "COMDAT ";
6478
6479   snprintf (buff, 14, _("[0x%x: "), flags);
6480
6481   flags &= ~ GRP_COMDAT;
6482   if (flags & GRP_MASKOS)
6483     {
6484       strcat (buff, "<OS specific>");
6485       flags &= ~ GRP_MASKOS;
6486     }
6487
6488   if (flags & GRP_MASKPROC)
6489     {
6490       strcat (buff, "<PROC specific>");
6491       flags &= ~ GRP_MASKPROC;
6492     }
6493
6494   if (flags)
6495     strcat (buff, "<unknown>");
6496
6497   strcat (buff, "]");
6498   return buff;
6499 }
6500
6501 static bfd_boolean
6502 process_section_groups (FILE * file)
6503 {
6504   Elf_Internal_Shdr * section;
6505   unsigned int i;
6506   struct group * group;
6507   Elf_Internal_Shdr * symtab_sec;
6508   Elf_Internal_Shdr * strtab_sec;
6509   Elf_Internal_Sym * symtab;
6510   unsigned long num_syms;
6511   char * strtab;
6512   size_t strtab_size;
6513
6514   /* Don't process section groups unless needed.  */
6515   if (!do_unwind && !do_section_groups)
6516     return TRUE;
6517
6518   if (elf_header.e_shnum == 0)
6519     {
6520       if (do_section_groups)
6521         printf (_("\nThere are no sections to group in this file.\n"));
6522
6523       return TRUE;
6524     }
6525
6526   if (section_headers == NULL)
6527     {
6528       error (_("Section headers are not available!\n"));
6529       /* PR 13622: This can happen with a corrupt ELF header.  */
6530       return FALSE;
6531     }
6532
6533   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6534                                                      sizeof (struct group *));
6535
6536   if (section_headers_groups == NULL)
6537     {
6538       error (_("Out of memory reading %u section group headers\n"),
6539              elf_header.e_shnum);
6540       return FALSE;
6541     }
6542
6543   /* Scan the sections for the group section.  */
6544   group_count = 0;
6545   for (i = 0, section = section_headers;
6546        i < elf_header.e_shnum;
6547        i++, section++)
6548     if (section->sh_type == SHT_GROUP)
6549       group_count++;
6550
6551   if (group_count == 0)
6552     {
6553       if (do_section_groups)
6554         printf (_("\nThere are no section groups in this file.\n"));
6555
6556       return TRUE;
6557     }
6558
6559   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6560
6561   if (section_groups == NULL)
6562     {
6563       error (_("Out of memory reading %lu groups\n"),
6564              (unsigned long) group_count);
6565       return FALSE;
6566     }
6567
6568   symtab_sec = NULL;
6569   strtab_sec = NULL;
6570   symtab = NULL;
6571   num_syms = 0;
6572   strtab = NULL;
6573   strtab_size = 0;
6574   for (i = 0, section = section_headers, group = section_groups;
6575        i < elf_header.e_shnum;
6576        i++, section++)
6577     {
6578       if (section->sh_type == SHT_GROUP)
6579         {
6580           const char * name = printable_section_name (section);
6581           const char * group_name;
6582           unsigned char * start;
6583           unsigned char * indices;
6584           unsigned int entry, j, size;
6585           Elf_Internal_Shdr * sec;
6586           Elf_Internal_Sym * sym;
6587
6588           /* Get the symbol table.  */
6589           if (section->sh_link >= elf_header.e_shnum
6590               || ((sec = section_headers + section->sh_link)->sh_type
6591                   != SHT_SYMTAB))
6592             {
6593               error (_("Bad sh_link in group section `%s'\n"), name);
6594               continue;
6595             }
6596
6597           if (symtab_sec != sec)
6598             {
6599               symtab_sec = sec;
6600               if (symtab)
6601                 free (symtab);
6602               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6603             }
6604
6605           if (symtab == NULL)
6606             {
6607               error (_("Corrupt header in group section `%s'\n"), name);
6608               continue;
6609             }
6610
6611           if (section->sh_info >= num_syms)
6612             {
6613               error (_("Bad sh_info in group section `%s'\n"), name);
6614               continue;
6615             }
6616
6617           sym = symtab + section->sh_info;
6618
6619           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6620             {
6621               if (sym->st_shndx == 0
6622                   || sym->st_shndx >= elf_header.e_shnum)
6623                 {
6624                   error (_("Bad sh_info in group section `%s'\n"), name);
6625                   continue;
6626                 }
6627
6628               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6629               strtab_sec = NULL;
6630               if (strtab)
6631                 free (strtab);
6632               strtab = NULL;
6633               strtab_size = 0;
6634             }
6635           else
6636             {
6637               /* Get the string table.  */
6638               if (symtab_sec->sh_link >= elf_header.e_shnum)
6639                 {
6640                   strtab_sec = NULL;
6641                   if (strtab)
6642                     free (strtab);
6643                   strtab = NULL;
6644                   strtab_size = 0;
6645                 }
6646               else if (strtab_sec
6647                        != (sec = section_headers + symtab_sec->sh_link))
6648                 {
6649                   strtab_sec = sec;
6650                   if (strtab)
6651                     free (strtab);
6652
6653                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6654                                               1, strtab_sec->sh_size,
6655                                               _("string table"));
6656                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6657                 }
6658               group_name = sym->st_name < strtab_size
6659                 ? strtab + sym->st_name : _("<corrupt>");
6660             }
6661
6662           /* PR 17531: file: loop.  */
6663           if (section->sh_entsize > section->sh_size)
6664             {
6665               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6666                      printable_section_name (section),
6667                      (unsigned long) section->sh_entsize,
6668                      (unsigned long) section->sh_size);
6669               break;
6670             }
6671
6672           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6673                                               1, section->sh_size,
6674                                               _("section data"));
6675           if (start == NULL)
6676             continue;
6677
6678           indices = start;
6679           size = (section->sh_size / section->sh_entsize) - 1;
6680           entry = byte_get (indices, 4);
6681           indices += 4;
6682
6683           if (do_section_groups)
6684             {
6685               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6686                       get_group_flags (entry), i, name, group_name, size);
6687
6688               printf (_("   [Index]    Name\n"));
6689             }
6690
6691           group->group_index = i;
6692
6693           for (j = 0; j < size; j++)
6694             {
6695               struct group_list * g;
6696
6697               entry = byte_get (indices, 4);
6698               indices += 4;
6699
6700               if (entry >= elf_header.e_shnum)
6701                 {
6702                   static unsigned num_group_errors = 0;
6703
6704                   if (num_group_errors ++ < 10)
6705                     {
6706                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6707                              entry, i, elf_header.e_shnum - 1);
6708                       if (num_group_errors == 10)
6709                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6710                     }
6711                   continue;
6712                 }
6713
6714               if (section_headers_groups [entry] != NULL)
6715                 {
6716                   if (entry)
6717                     {
6718                       static unsigned num_errs = 0;
6719
6720                       if (num_errs ++ < 10)
6721                         {
6722                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6723                                  entry, i,
6724                                  section_headers_groups [entry]->group_index);
6725                           if (num_errs == 10)
6726                             warn (_("Further error messages about already contained group sections suppressed\n"));
6727                         }
6728                       continue;
6729                     }
6730                   else
6731                     {
6732                       /* Intel C/C++ compiler may put section 0 in a
6733                          section group.  We just warn it the first time
6734                          and ignore it afterwards.  */
6735                       static bfd_boolean warned = FALSE;
6736                       if (!warned)
6737                         {
6738                           error (_("section 0 in group section [%5u]\n"),
6739                                  section_headers_groups [entry]->group_index);
6740                           warned = TRUE;
6741                         }
6742                     }
6743                 }
6744
6745               section_headers_groups [entry] = group;
6746
6747               if (do_section_groups)
6748                 {
6749                   sec = section_headers + entry;
6750                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6751                 }
6752
6753               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6754               g->section_index = entry;
6755               g->next = group->root;
6756               group->root = g;
6757             }
6758
6759           if (start)
6760             free (start);
6761
6762           group++;
6763         }
6764     }
6765
6766   if (symtab)
6767     free (symtab);
6768   if (strtab)
6769     free (strtab);
6770   return TRUE;
6771 }
6772
6773 /* Data used to display dynamic fixups.  */
6774
6775 struct ia64_vms_dynfixup
6776 {
6777   bfd_vma needed_ident;         /* Library ident number.  */
6778   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6779   bfd_vma fixup_needed;         /* Index of the library.  */
6780   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6781   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6782 };
6783
6784 /* Data used to display dynamic relocations.  */
6785
6786 struct ia64_vms_dynimgrela
6787 {
6788   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6789   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6790 };
6791
6792 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6793    library).  */
6794
6795 static bfd_boolean
6796 dump_ia64_vms_dynamic_fixups (FILE * file,
6797                               struct ia64_vms_dynfixup * fixup,
6798                               const char * strtab,
6799                               unsigned int strtab_sz)
6800 {
6801   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6802   long i;
6803   const char * lib_name;
6804
6805   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6806                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6807                    _("dynamic section image fixups"));
6808   if (!imfs)
6809     return FALSE;
6810
6811   if (fixup->needed < strtab_sz)
6812     lib_name = strtab + fixup->needed;
6813   else
6814     {
6815       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6816             (unsigned long) fixup->needed);
6817       lib_name = "???";
6818     }
6819   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6820           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6821   printf
6822     (_("Seg Offset           Type                             SymVec DataType\n"));
6823
6824   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6825     {
6826       unsigned int type;
6827       const char *rtype;
6828
6829       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6830       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6831       type = BYTE_GET (imfs [i].type);
6832       rtype = elf_ia64_reloc_type (type);
6833       if (rtype == NULL)
6834         printf (" 0x%08x                       ", type);
6835       else
6836         printf (" %-32s ", rtype);
6837       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6838       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6839     }
6840
6841   free (imfs);
6842   return TRUE;
6843 }
6844
6845 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6846
6847 static bfd_boolean
6848 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6849 {
6850   Elf64_External_VMS_IMAGE_RELA *imrs;
6851   long i;
6852
6853   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6854                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6855                    _("dynamic section image relocations"));
6856   if (!imrs)
6857     return FALSE;
6858
6859   printf (_("\nImage relocs\n"));
6860   printf
6861     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6862
6863   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6864     {
6865       unsigned int type;
6866       const char *rtype;
6867
6868       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6869       printf ("%08" BFD_VMA_FMT "x ",
6870               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6871       type = BYTE_GET (imrs [i].type);
6872       rtype = elf_ia64_reloc_type (type);
6873       if (rtype == NULL)
6874         printf ("0x%08x                      ", type);
6875       else
6876         printf ("%-31s ", rtype);
6877       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6878       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6879       printf ("%08" BFD_VMA_FMT "x\n",
6880               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6881     }
6882
6883   free (imrs);
6884   return TRUE;
6885 }
6886
6887 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6888
6889 static bfd_boolean
6890 process_ia64_vms_dynamic_relocs (FILE *file)
6891 {
6892   struct ia64_vms_dynfixup fixup;
6893   struct ia64_vms_dynimgrela imgrela;
6894   Elf_Internal_Dyn *entry;
6895   bfd_vma strtab_off = 0;
6896   bfd_vma strtab_sz = 0;
6897   char *strtab = NULL;
6898   bfd_boolean res = TRUE;
6899
6900   memset (&fixup, 0, sizeof (fixup));
6901   memset (&imgrela, 0, sizeof (imgrela));
6902
6903   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6904   for (entry = dynamic_section;
6905        entry < dynamic_section + dynamic_nent;
6906        entry++)
6907     {
6908       switch (entry->d_tag)
6909         {
6910         case DT_IA_64_VMS_STRTAB_OFFSET:
6911           strtab_off = entry->d_un.d_val;
6912           break;
6913         case DT_STRSZ:
6914           strtab_sz = entry->d_un.d_val;
6915           if (strtab == NULL)
6916             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6917                                1, strtab_sz, _("dynamic string section"));
6918           break;
6919
6920         case DT_IA_64_VMS_NEEDED_IDENT:
6921           fixup.needed_ident = entry->d_un.d_val;
6922           break;
6923         case DT_NEEDED:
6924           fixup.needed = entry->d_un.d_val;
6925           break;
6926         case DT_IA_64_VMS_FIXUP_NEEDED:
6927           fixup.fixup_needed = entry->d_un.d_val;
6928           break;
6929         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6930           fixup.fixup_rela_cnt = entry->d_un.d_val;
6931           break;
6932         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6933           fixup.fixup_rela_off = entry->d_un.d_val;
6934           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6935             res = FALSE;
6936           break;
6937         case DT_IA_64_VMS_IMG_RELA_CNT:
6938           imgrela.img_rela_cnt = entry->d_un.d_val;
6939           break;
6940         case DT_IA_64_VMS_IMG_RELA_OFF:
6941           imgrela.img_rela_off = entry->d_un.d_val;
6942           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6943             res = FALSE;
6944           break;
6945
6946         default:
6947           break;
6948         }
6949     }
6950
6951   if (strtab != NULL)
6952     free (strtab);
6953
6954   return res;
6955 }
6956
6957 static struct
6958 {
6959   const char * name;
6960   int reloc;
6961   int size;
6962   int rela;
6963 }
6964   dynamic_relocations [] =
6965 {
6966   { "REL", DT_REL, DT_RELSZ, FALSE },
6967   { "RELA", DT_RELA, DT_RELASZ, TRUE },
6968   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6969 };
6970
6971 /* Process the reloc section.  */
6972
6973 static bfd_boolean
6974 process_relocs (FILE * file)
6975 {
6976   unsigned long rel_size;
6977   unsigned long rel_offset;
6978
6979   if (!do_reloc)
6980     return TRUE;
6981
6982   if (do_using_dynamic)
6983     {
6984       int          is_rela;
6985       const char * name;
6986       bfd_boolean  has_dynamic_reloc;
6987       unsigned int i;
6988
6989       has_dynamic_reloc = FALSE;
6990
6991       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6992         {
6993           is_rela = dynamic_relocations [i].rela;
6994           name = dynamic_relocations [i].name;
6995           rel_size = dynamic_info [dynamic_relocations [i].size];
6996           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6997
6998           if (rel_size)
6999             has_dynamic_reloc = TRUE;
7000
7001           if (is_rela == UNKNOWN)
7002             {
7003               if (dynamic_relocations [i].reloc == DT_JMPREL)
7004                 switch (dynamic_info[DT_PLTREL])
7005                   {
7006                   case DT_REL:
7007                     is_rela = FALSE;
7008                     break;
7009                   case DT_RELA:
7010                     is_rela = TRUE;
7011                     break;
7012                   }
7013             }
7014
7015           if (rel_size)
7016             {
7017               printf
7018                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7019                  name, rel_offset, rel_size);
7020
7021               dump_relocations (file,
7022                                 offset_from_vma (file, rel_offset, rel_size),
7023                                 rel_size,
7024                                 dynamic_symbols, num_dynamic_syms,
7025                                 dynamic_strings, dynamic_strings_length,
7026                                 is_rela, TRUE /* is_dynamic */);
7027             }
7028         }
7029
7030       if (is_ia64_vms ())
7031         if (process_ia64_vms_dynamic_relocs (file))
7032           has_dynamic_reloc = TRUE;
7033
7034       if (! has_dynamic_reloc)
7035         printf (_("\nThere are no dynamic relocations in this file.\n"));
7036     }
7037   else
7038     {
7039       Elf_Internal_Shdr * section;
7040       unsigned long i;
7041       bfd_boolean found = FALSE;
7042
7043       for (i = 0, section = section_headers;
7044            i < elf_header.e_shnum;
7045            i++, section++)
7046         {
7047           if (   section->sh_type != SHT_RELA
7048               && section->sh_type != SHT_REL)
7049             continue;
7050
7051           rel_offset = section->sh_offset;
7052           rel_size   = section->sh_size;
7053
7054           if (rel_size)
7055             {
7056               Elf_Internal_Shdr * strsec;
7057               int is_rela;
7058
7059               printf (_("\nRelocation section "));
7060
7061               if (string_table == NULL)
7062                 printf ("%d", section->sh_name);
7063               else
7064                 printf ("'%s'", printable_section_name (section));
7065
7066               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7067                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7068
7069               is_rela = section->sh_type == SHT_RELA;
7070
7071               if (section->sh_link != 0
7072                   && section->sh_link < elf_header.e_shnum)
7073                 {
7074                   Elf_Internal_Shdr * symsec;
7075                   Elf_Internal_Sym *  symtab;
7076                   unsigned long nsyms;
7077                   unsigned long strtablen = 0;
7078                   char * strtab = NULL;
7079
7080                   symsec = section_headers + section->sh_link;
7081                   if (symsec->sh_type != SHT_SYMTAB
7082                       && symsec->sh_type != SHT_DYNSYM)
7083                     continue;
7084
7085                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7086
7087                   if (symtab == NULL)
7088                     continue;
7089
7090                   if (symsec->sh_link != 0
7091                       && symsec->sh_link < elf_header.e_shnum)
7092                     {
7093                       strsec = section_headers + symsec->sh_link;
7094
7095                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7096                                                   1, strsec->sh_size,
7097                                                   _("string table"));
7098                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7099                     }
7100
7101                   dump_relocations (file, rel_offset, rel_size,
7102                                     symtab, nsyms, strtab, strtablen,
7103                                     is_rela,
7104                                     symsec->sh_type == SHT_DYNSYM);
7105                   if (strtab)
7106                     free (strtab);
7107                   free (symtab);
7108                 }
7109               else
7110                 dump_relocations (file, rel_offset, rel_size,
7111                                   NULL, 0, NULL, 0, is_rela,
7112                                   FALSE /* is_dynamic */);
7113
7114               found = TRUE;
7115             }
7116         }
7117
7118       if (! found)
7119         printf (_("\nThere are no relocations in this file.\n"));
7120     }
7121
7122   return TRUE;
7123 }
7124
7125 /* An absolute address consists of a section and an offset.  If the
7126    section is NULL, the offset itself is the address, otherwise, the
7127    address equals to LOAD_ADDRESS(section) + offset.  */
7128
7129 struct absaddr
7130 {
7131   unsigned short section;
7132   bfd_vma offset;
7133 };
7134
7135 #define ABSADDR(a) \
7136   ((a).section \
7137    ? section_headers [(a).section].sh_addr + (a).offset \
7138    : (a).offset)
7139
7140 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7141    name, if found, and the offset from the symbol to ADDR.  */
7142
7143 static void
7144 find_symbol_for_address (Elf_Internal_Sym * symtab,
7145                          unsigned long      nsyms,
7146                          const char *       strtab,
7147                          unsigned long      strtab_size,
7148                          struct absaddr     addr,
7149                          const char **      symname,
7150                          bfd_vma *          offset)
7151 {
7152   bfd_vma dist = 0x100000;
7153   Elf_Internal_Sym * sym;
7154   Elf_Internal_Sym * beg;
7155   Elf_Internal_Sym * end;
7156   Elf_Internal_Sym * best = NULL;
7157
7158   REMOVE_ARCH_BITS (addr.offset);
7159   beg = symtab;
7160   end = symtab + nsyms;
7161
7162   while (beg < end)
7163     {
7164       bfd_vma value;
7165
7166       sym = beg + (end - beg) / 2;
7167
7168       value = sym->st_value;
7169       REMOVE_ARCH_BITS (value);
7170
7171       if (sym->st_name != 0
7172           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7173           && addr.offset >= value
7174           && addr.offset - value < dist)
7175         {
7176           best = sym;
7177           dist = addr.offset - value;
7178           if (!dist)
7179             break;
7180         }
7181
7182       if (addr.offset < value)
7183         end = sym;
7184       else
7185         beg = sym + 1;
7186     }
7187
7188   if (best)
7189     {
7190       *symname = (best->st_name >= strtab_size
7191                   ? _("<corrupt>") : strtab + best->st_name);
7192       *offset = dist;
7193       return;
7194     }
7195
7196   *symname = NULL;
7197   *offset = addr.offset;
7198 }
7199
7200 static /* signed */ int
7201 symcmp (const void *p, const void *q)
7202 {
7203   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7204   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7205
7206   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7207 }
7208
7209 /* Process the unwind section.  */
7210
7211 #include "unwind-ia64.h"
7212
7213 struct ia64_unw_table_entry
7214 {
7215   struct absaddr start;
7216   struct absaddr end;
7217   struct absaddr info;
7218 };
7219
7220 struct ia64_unw_aux_info
7221 {
7222   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7223   unsigned long                 table_len;      /* Length of unwind table.  */
7224   unsigned char *               info;           /* Unwind info.  */
7225   unsigned long                 info_size;      /* Size of unwind info.  */
7226   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7227   bfd_vma                       seg_base;       /* Starting address of segment.  */
7228   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7229   unsigned long                 nsyms;          /* Number of symbols.  */
7230   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7231   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7232   char *                        strtab;         /* The string table.  */
7233   unsigned long                 strtab_size;    /* Size of string table.  */
7234 };
7235
7236 static bfd_boolean
7237 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7238 {
7239   struct ia64_unw_table_entry * tp;
7240   unsigned long j, nfuns;
7241   int in_body;
7242   bfd_boolean res = TRUE;
7243
7244   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7245   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7246     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7247       aux->funtab[nfuns++] = aux->symtab[j];
7248   aux->nfuns = nfuns;
7249   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7250
7251   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7252     {
7253       bfd_vma stamp;
7254       bfd_vma offset;
7255       const unsigned char * dp;
7256       const unsigned char * head;
7257       const unsigned char * end;
7258       const char * procname;
7259
7260       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7261                                aux->strtab_size, tp->start, &procname, &offset);
7262
7263       fputs ("\n<", stdout);
7264
7265       if (procname)
7266         {
7267           fputs (procname, stdout);
7268
7269           if (offset)
7270             printf ("+%lx", (unsigned long) offset);
7271         }
7272
7273       fputs (">: [", stdout);
7274       print_vma (tp->start.offset, PREFIX_HEX);
7275       fputc ('-', stdout);
7276       print_vma (tp->end.offset, PREFIX_HEX);
7277       printf ("], info at +0x%lx\n",
7278               (unsigned long) (tp->info.offset - aux->seg_base));
7279
7280       /* PR 17531: file: 86232b32.  */
7281       if (aux->info == NULL)
7282         continue;
7283
7284       /* PR 17531: file: 0997b4d1.  */
7285       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7286         {
7287           warn (_("Invalid offset %lx in table entry %ld\n"),
7288                 (long) tp->info.offset, (long) (tp - aux->table));
7289           res = FALSE;
7290           continue;
7291         }
7292
7293       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7294       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7295
7296       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7297               (unsigned) UNW_VER (stamp),
7298               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7299               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7300               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7301               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7302
7303       if (UNW_VER (stamp) != 1)
7304         {
7305           printf (_("\tUnknown version.\n"));
7306           continue;
7307         }
7308
7309       in_body = 0;
7310       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7311       /* PR 17531: file: 16ceda89.  */
7312       if (end > aux->info + aux->info_size)
7313         end = aux->info + aux->info_size;
7314       for (dp = head + 8; dp < end;)
7315         dp = unw_decode (dp, in_body, & in_body, end);
7316     }
7317
7318   free (aux->funtab);
7319
7320   return res;
7321 }
7322
7323 static bfd_boolean
7324 slurp_ia64_unwind_table (FILE * file,
7325                          struct ia64_unw_aux_info * aux,
7326                          Elf_Internal_Shdr * sec)
7327 {
7328   unsigned long size, nrelas, i;
7329   Elf_Internal_Phdr * seg;
7330   struct ia64_unw_table_entry * tep;
7331   Elf_Internal_Shdr * relsec;
7332   Elf_Internal_Rela * rela;
7333   Elf_Internal_Rela * rp;
7334   unsigned char * table;
7335   unsigned char * tp;
7336   Elf_Internal_Sym * sym;
7337   const char * relname;
7338
7339   aux->table_len = 0;
7340
7341   /* First, find the starting address of the segment that includes
7342      this section: */
7343
7344   if (elf_header.e_phnum)
7345     {
7346       if (! get_program_headers (file))
7347           return FALSE;
7348
7349       for (seg = program_headers;
7350            seg < program_headers + elf_header.e_phnum;
7351            ++seg)
7352         {
7353           if (seg->p_type != PT_LOAD)
7354             continue;
7355
7356           if (sec->sh_addr >= seg->p_vaddr
7357               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7358             {
7359               aux->seg_base = seg->p_vaddr;
7360               break;
7361             }
7362         }
7363     }
7364
7365   /* Second, build the unwind table from the contents of the unwind section:  */
7366   size = sec->sh_size;
7367   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7368                                       _("unwind table"));
7369   if (!table)
7370     return FALSE;
7371
7372   aux->table_len = size / (3 * eh_addr_size);
7373   aux->table = (struct ia64_unw_table_entry *)
7374     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7375   tep = aux->table;
7376
7377   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7378     {
7379       tep->start.section = SHN_UNDEF;
7380       tep->end.section   = SHN_UNDEF;
7381       tep->info.section  = SHN_UNDEF;
7382       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7383       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7384       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7385       tep->start.offset += aux->seg_base;
7386       tep->end.offset   += aux->seg_base;
7387       tep->info.offset  += aux->seg_base;
7388     }
7389   free (table);
7390
7391   /* Third, apply any relocations to the unwind table:  */
7392   for (relsec = section_headers;
7393        relsec < section_headers + elf_header.e_shnum;
7394        ++relsec)
7395     {
7396       if (relsec->sh_type != SHT_RELA
7397           || relsec->sh_info >= elf_header.e_shnum
7398           || section_headers + relsec->sh_info != sec)
7399         continue;
7400
7401       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7402                               & rela, & nrelas))
7403         {
7404           free (aux->table);
7405           aux->table = NULL;
7406           aux->table_len = 0;
7407           return FALSE;
7408         }
7409
7410       for (rp = rela; rp < rela + nrelas; ++rp)
7411         {
7412           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7413           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7414
7415           /* PR 17531: file: 9fa67536.  */
7416           if (relname == NULL)
7417             {
7418               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7419               continue;
7420             }
7421
7422           if (! const_strneq (relname, "R_IA64_SEGREL"))
7423             {
7424               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7425               continue;
7426             }
7427
7428           i = rp->r_offset / (3 * eh_addr_size);
7429
7430           /* PR 17531: file: 5bc8d9bf.  */
7431           if (i >= aux->table_len)
7432             {
7433               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7434               continue;
7435             }
7436
7437           switch (rp->r_offset / eh_addr_size % 3)
7438             {
7439             case 0:
7440               aux->table[i].start.section = sym->st_shndx;
7441               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7442               break;
7443             case 1:
7444               aux->table[i].end.section   = sym->st_shndx;
7445               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7446               break;
7447             case 2:
7448               aux->table[i].info.section  = sym->st_shndx;
7449               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7450               break;
7451             default:
7452               break;
7453             }
7454         }
7455
7456       free (rela);
7457     }
7458
7459   return TRUE;
7460 }
7461
7462 static bfd_boolean
7463 ia64_process_unwind (FILE * file)
7464 {
7465   Elf_Internal_Shdr * sec;
7466   Elf_Internal_Shdr * unwsec = NULL;
7467   Elf_Internal_Shdr * strsec;
7468   unsigned long i, unwcount = 0, unwstart = 0;
7469   struct ia64_unw_aux_info aux;
7470   bfd_boolean res = TRUE;
7471
7472   memset (& aux, 0, sizeof (aux));
7473
7474   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7475     {
7476       if (sec->sh_type == SHT_SYMTAB
7477           && sec->sh_link < elf_header.e_shnum)
7478         {
7479           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7480
7481           strsec = section_headers + sec->sh_link;
7482           if (aux.strtab != NULL)
7483             {
7484               error (_("Multiple auxillary string tables encountered\n"));
7485               free (aux.strtab);
7486               res = FALSE;
7487             }
7488           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7489                                           1, strsec->sh_size,
7490                                           _("string table"));
7491           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7492         }
7493       else if (sec->sh_type == SHT_IA_64_UNWIND)
7494         unwcount++;
7495     }
7496
7497   if (!unwcount)
7498     printf (_("\nThere are no unwind sections in this file.\n"));
7499
7500   while (unwcount-- > 0)
7501     {
7502       char * suffix;
7503       size_t len, len2;
7504
7505       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7506            i < elf_header.e_shnum; ++i, ++sec)
7507         if (sec->sh_type == SHT_IA_64_UNWIND)
7508           {
7509             unwsec = sec;
7510             break;
7511           }
7512       /* We have already counted the number of SHT_IA64_UNWIND
7513          sections so the loop above should never fail.  */
7514       assert (unwsec != NULL);
7515
7516       unwstart = i + 1;
7517       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7518
7519       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7520         {
7521           /* We need to find which section group it is in.  */
7522           struct group_list * g;
7523
7524           if (section_headers_groups == NULL
7525               || section_headers_groups [i] == NULL)
7526             i = elf_header.e_shnum;
7527           else
7528             {
7529               g = section_headers_groups [i]->root;
7530
7531               for (; g != NULL; g = g->next)
7532                 {
7533                   sec = section_headers + g->section_index;
7534
7535                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7536                     break;
7537                 }
7538
7539               if (g == NULL)
7540                 i = elf_header.e_shnum;
7541             }
7542         }
7543       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7544         {
7545           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7546           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7547           suffix = SECTION_NAME (unwsec) + len;
7548           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7549                ++i, ++sec)
7550             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7551                 && streq (SECTION_NAME (sec) + len2, suffix))
7552               break;
7553         }
7554       else
7555         {
7556           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7557              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7558           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7559           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7560           suffix = "";
7561           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7562             suffix = SECTION_NAME (unwsec) + len;
7563           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7564                ++i, ++sec)
7565             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7566                 && streq (SECTION_NAME (sec) + len2, suffix))
7567               break;
7568         }
7569
7570       if (i == elf_header.e_shnum)
7571         {
7572           printf (_("\nCould not find unwind info section for "));
7573
7574           if (string_table == NULL)
7575             printf ("%d", unwsec->sh_name);
7576           else
7577             printf ("'%s'", printable_section_name (unwsec));
7578         }
7579       else
7580         {
7581           aux.info_addr = sec->sh_addr;
7582           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7583                                                  sec->sh_size,
7584                                                  _("unwind info"));
7585           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7586
7587           printf (_("\nUnwind section "));
7588
7589           if (string_table == NULL)
7590             printf ("%d", unwsec->sh_name);
7591           else
7592             printf ("'%s'", printable_section_name (unwsec));
7593
7594           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7595                   (unsigned long) unwsec->sh_offset,
7596                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7597
7598           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7599               && aux.table_len > 0)
7600             dump_ia64_unwind (& aux);
7601
7602           if (aux.table)
7603             free ((char *) aux.table);
7604           if (aux.info)
7605             free ((char *) aux.info);
7606           aux.table = NULL;
7607           aux.info = NULL;
7608         }
7609     }
7610
7611   if (aux.symtab)
7612     free (aux.symtab);
7613   if (aux.strtab)
7614     free ((char *) aux.strtab);
7615
7616   return res;
7617 }
7618
7619 struct hppa_unw_table_entry
7620 {
7621   struct absaddr start;
7622   struct absaddr end;
7623   unsigned int Cannot_unwind:1;                 /* 0 */
7624   unsigned int Millicode:1;                     /* 1 */
7625   unsigned int Millicode_save_sr0:1;            /* 2 */
7626   unsigned int Region_description:2;            /* 3..4 */
7627   unsigned int reserved1:1;                     /* 5 */
7628   unsigned int Entry_SR:1;                      /* 6 */
7629   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7630   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7631   unsigned int Args_stored:1;                   /* 16 */
7632   unsigned int Variable_Frame:1;                /* 17 */
7633   unsigned int Separate_Package_Body:1;         /* 18 */
7634   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7635   unsigned int Stack_Overflow_Check:1;          /* 20 */
7636   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7637   unsigned int Ada_Region:1;                    /* 22 */
7638   unsigned int cxx_info:1;                      /* 23 */
7639   unsigned int cxx_try_catch:1;                 /* 24 */
7640   unsigned int sched_entry_seq:1;               /* 25 */
7641   unsigned int reserved2:1;                     /* 26 */
7642   unsigned int Save_SP:1;                       /* 27 */
7643   unsigned int Save_RP:1;                       /* 28 */
7644   unsigned int Save_MRP_in_frame:1;             /* 29 */
7645   unsigned int extn_ptr_defined:1;              /* 30 */
7646   unsigned int Cleanup_defined:1;               /* 31 */
7647
7648   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7649   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7650   unsigned int Large_frame:1;                   /* 2 */
7651   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7652   unsigned int reserved4:1;                     /* 4 */
7653   unsigned int Total_frame_size:27;             /* 5..31 */
7654 };
7655
7656 struct hppa_unw_aux_info
7657 {
7658   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7659   unsigned long                  table_len;     /* Length of unwind table.  */
7660   bfd_vma                        seg_base;      /* Starting address of segment.  */
7661   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7662   unsigned long                  nsyms;         /* Number of symbols.  */
7663   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7664   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7665   char *                         strtab;        /* The string table.  */
7666   unsigned long                  strtab_size;   /* Size of string table.  */
7667 };
7668
7669 static bfd_boolean
7670 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7671 {
7672   struct hppa_unw_table_entry * tp;
7673   unsigned long j, nfuns;
7674   bfd_boolean res = TRUE;
7675
7676   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7677   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7678     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7679       aux->funtab[nfuns++] = aux->symtab[j];
7680   aux->nfuns = nfuns;
7681   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7682
7683   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7684     {
7685       bfd_vma offset;
7686       const char * procname;
7687
7688       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7689                                aux->strtab_size, tp->start, &procname,
7690                                &offset);
7691
7692       fputs ("\n<", stdout);
7693
7694       if (procname)
7695         {
7696           fputs (procname, stdout);
7697
7698           if (offset)
7699             printf ("+%lx", (unsigned long) offset);
7700         }
7701
7702       fputs (">: [", stdout);
7703       print_vma (tp->start.offset, PREFIX_HEX);
7704       fputc ('-', stdout);
7705       print_vma (tp->end.offset, PREFIX_HEX);
7706       printf ("]\n\t");
7707
7708 #define PF(_m) if (tp->_m) printf (#_m " ");
7709 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7710       PF(Cannot_unwind);
7711       PF(Millicode);
7712       PF(Millicode_save_sr0);
7713       /* PV(Region_description);  */
7714       PF(Entry_SR);
7715       PV(Entry_FR);
7716       PV(Entry_GR);
7717       PF(Args_stored);
7718       PF(Variable_Frame);
7719       PF(Separate_Package_Body);
7720       PF(Frame_Extension_Millicode);
7721       PF(Stack_Overflow_Check);
7722       PF(Two_Instruction_SP_Increment);
7723       PF(Ada_Region);
7724       PF(cxx_info);
7725       PF(cxx_try_catch);
7726       PF(sched_entry_seq);
7727       PF(Save_SP);
7728       PF(Save_RP);
7729       PF(Save_MRP_in_frame);
7730       PF(extn_ptr_defined);
7731       PF(Cleanup_defined);
7732       PF(MPE_XL_interrupt_marker);
7733       PF(HP_UX_interrupt_marker);
7734       PF(Large_frame);
7735       PF(Pseudo_SP_Set);
7736       PV(Total_frame_size);
7737 #undef PF
7738 #undef PV
7739     }
7740
7741   printf ("\n");
7742
7743   free (aux->funtab);
7744
7745   return res;
7746 }
7747
7748 static bfd_boolean
7749 slurp_hppa_unwind_table (FILE * file,
7750                          struct hppa_unw_aux_info * aux,
7751                          Elf_Internal_Shdr * sec)
7752 {
7753   unsigned long size, unw_ent_size, nentries, nrelas, i;
7754   Elf_Internal_Phdr * seg;
7755   struct hppa_unw_table_entry * tep;
7756   Elf_Internal_Shdr * relsec;
7757   Elf_Internal_Rela * rela;
7758   Elf_Internal_Rela * rp;
7759   unsigned char * table;
7760   unsigned char * tp;
7761   Elf_Internal_Sym * sym;
7762   const char * relname;
7763
7764   /* First, find the starting address of the segment that includes
7765      this section.  */
7766   if (elf_header.e_phnum)
7767     {
7768       if (! get_program_headers (file))
7769         return FALSE;
7770
7771       for (seg = program_headers;
7772            seg < program_headers + elf_header.e_phnum;
7773            ++seg)
7774         {
7775           if (seg->p_type != PT_LOAD)
7776             continue;
7777
7778           if (sec->sh_addr >= seg->p_vaddr
7779               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7780             {
7781               aux->seg_base = seg->p_vaddr;
7782               break;
7783             }
7784         }
7785     }
7786
7787   /* Second, build the unwind table from the contents of the unwind
7788      section.  */
7789   size = sec->sh_size;
7790   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7791                                       _("unwind table"));
7792   if (!table)
7793     return FALSE;
7794
7795   unw_ent_size = 16;
7796   nentries = size / unw_ent_size;
7797   size = unw_ent_size * nentries;
7798
7799   tep = aux->table = (struct hppa_unw_table_entry *)
7800       xcmalloc (nentries, sizeof (aux->table[0]));
7801
7802   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7803     {
7804       unsigned int tmp1, tmp2;
7805
7806       tep->start.section = SHN_UNDEF;
7807       tep->end.section   = SHN_UNDEF;
7808
7809       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7810       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7811       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7812       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7813
7814       tep->start.offset += aux->seg_base;
7815       tep->end.offset   += aux->seg_base;
7816
7817       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7818       tep->Millicode = (tmp1 >> 30) & 0x1;
7819       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7820       tep->Region_description = (tmp1 >> 27) & 0x3;
7821       tep->reserved1 = (tmp1 >> 26) & 0x1;
7822       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7823       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7824       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7825       tep->Args_stored = (tmp1 >> 15) & 0x1;
7826       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7827       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7828       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7829       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7830       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7831       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7832       tep->cxx_info = (tmp1 >> 8) & 0x1;
7833       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7834       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7835       tep->reserved2 = (tmp1 >> 5) & 0x1;
7836       tep->Save_SP = (tmp1 >> 4) & 0x1;
7837       tep->Save_RP = (tmp1 >> 3) & 0x1;
7838       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7839       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7840       tep->Cleanup_defined = tmp1 & 0x1;
7841
7842       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7843       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7844       tep->Large_frame = (tmp2 >> 29) & 0x1;
7845       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7846       tep->reserved4 = (tmp2 >> 27) & 0x1;
7847       tep->Total_frame_size = tmp2 & 0x7ffffff;
7848     }
7849   free (table);
7850
7851   /* Third, apply any relocations to the unwind table.  */
7852   for (relsec = section_headers;
7853        relsec < section_headers + elf_header.e_shnum;
7854        ++relsec)
7855     {
7856       if (relsec->sh_type != SHT_RELA
7857           || relsec->sh_info >= elf_header.e_shnum
7858           || section_headers + relsec->sh_info != sec)
7859         continue;
7860
7861       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7862                               & rela, & nrelas))
7863         return FALSE;
7864
7865       for (rp = rela; rp < rela + nrelas; ++rp)
7866         {
7867           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7868           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7869
7870           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7871           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7872             {
7873               warn (_("Skipping unexpected relocation type %s\n"), relname);
7874               continue;
7875             }
7876
7877           i = rp->r_offset / unw_ent_size;
7878
7879           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7880             {
7881             case 0:
7882               aux->table[i].start.section = sym->st_shndx;
7883               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7884               break;
7885             case 1:
7886               aux->table[i].end.section   = sym->st_shndx;
7887               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7888               break;
7889             default:
7890               break;
7891             }
7892         }
7893
7894       free (rela);
7895     }
7896
7897   aux->table_len = nentries;
7898
7899   return TRUE;
7900 }
7901
7902 static bfd_boolean
7903 hppa_process_unwind (FILE * file)
7904 {
7905   struct hppa_unw_aux_info aux;
7906   Elf_Internal_Shdr * unwsec = NULL;
7907   Elf_Internal_Shdr * strsec;
7908   Elf_Internal_Shdr * sec;
7909   unsigned long i;
7910   bfd_boolean res = TRUE;
7911
7912   if (string_table == NULL)
7913     return FALSE;
7914
7915   memset (& aux, 0, sizeof (aux));
7916
7917   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7918     {
7919       if (sec->sh_type == SHT_SYMTAB
7920           && sec->sh_link < elf_header.e_shnum)
7921         {
7922           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7923
7924           strsec = section_headers + sec->sh_link;
7925           if (aux.strtab != NULL)
7926             {
7927               error (_("Multiple auxillary string tables encountered\n"));
7928               free (aux.strtab);
7929               res = FALSE;
7930             }
7931           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7932                                           1, strsec->sh_size,
7933                                           _("string table"));
7934           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7935         }
7936       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7937         unwsec = sec;
7938     }
7939
7940   if (!unwsec)
7941     printf (_("\nThere are no unwind sections in this file.\n"));
7942
7943   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7944     {
7945       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7946         {
7947           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7948                   printable_section_name (sec),
7949                   (unsigned long) sec->sh_offset,
7950                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7951
7952           if (! slurp_hppa_unwind_table (file, &aux, sec))
7953             res = FALSE;
7954
7955           if (aux.table_len > 0)
7956             {
7957               if (! dump_hppa_unwind (&aux))
7958                 res = FALSE;
7959             }
7960
7961           if (aux.table)
7962             free ((char *) aux.table);
7963           aux.table = NULL;
7964         }
7965     }
7966
7967   if (aux.symtab)
7968     free (aux.symtab);
7969   if (aux.strtab)
7970     free ((char *) aux.strtab);
7971
7972   return res;
7973 }
7974
7975 struct arm_section
7976 {
7977   unsigned char *      data;            /* The unwind data.  */
7978   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7979   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7980   unsigned long        nrelas;          /* The number of relocations.  */
7981   unsigned int         rel_type;        /* REL or RELA ?  */
7982   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7983 };
7984
7985 struct arm_unw_aux_info
7986 {
7987   FILE *              file;             /* The file containing the unwind sections.  */
7988   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7989   unsigned long       nsyms;            /* Number of symbols.  */
7990   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7991   unsigned long       nfuns;            /* Number of these symbols.  */
7992   char *              strtab;           /* The file's string table.  */
7993   unsigned long       strtab_size;      /* Size of string table.  */
7994 };
7995
7996 static const char *
7997 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7998                         bfd_vma fn, struct absaddr addr)
7999 {
8000   const char *procname;
8001   bfd_vma sym_offset;
8002
8003   if (addr.section == SHN_UNDEF)
8004     addr.offset = fn;
8005
8006   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8007                            aux->strtab_size, addr, &procname,
8008                            &sym_offset);
8009
8010   print_vma (fn, PREFIX_HEX);
8011
8012   if (procname)
8013     {
8014       fputs (" <", stdout);
8015       fputs (procname, stdout);
8016
8017       if (sym_offset)
8018         printf ("+0x%lx", (unsigned long) sym_offset);
8019       fputc ('>', stdout);
8020     }
8021
8022   return procname;
8023 }
8024
8025 static void
8026 arm_free_section (struct arm_section *arm_sec)
8027 {
8028   if (arm_sec->data != NULL)
8029     free (arm_sec->data);
8030
8031   if (arm_sec->rela != NULL)
8032     free (arm_sec->rela);
8033 }
8034
8035 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8036       cached section and install SEC instead.
8037    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8038       and return its valued in * WORDP, relocating if necessary.
8039    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8040       relocation's offset in ADDR.
8041    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8042       into the string table of the symbol associated with the reloc.  If no
8043       reloc was applied store -1 there.
8044    5) Return TRUE upon success, FALSE otherwise.  */
8045
8046 static bfd_boolean
8047 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8048                          struct arm_section *       arm_sec,
8049                          Elf_Internal_Shdr *        sec,
8050                          bfd_vma                    word_offset,
8051                          unsigned int *             wordp,
8052                          struct absaddr *           addr,
8053                          bfd_vma *                  sym_name)
8054 {
8055   Elf_Internal_Rela *rp;
8056   Elf_Internal_Sym *sym;
8057   const char * relname;
8058   unsigned int word;
8059   bfd_boolean wrapped;
8060
8061   if (sec == NULL || arm_sec == NULL)
8062     return FALSE;
8063
8064   addr->section = SHN_UNDEF;
8065   addr->offset = 0;
8066
8067   if (sym_name != NULL)
8068     *sym_name = (bfd_vma) -1;
8069
8070   /* If necessary, update the section cache.  */
8071   if (sec != arm_sec->sec)
8072     {
8073       Elf_Internal_Shdr *relsec;
8074
8075       arm_free_section (arm_sec);
8076
8077       arm_sec->sec = sec;
8078       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8079                                 sec->sh_size, _("unwind data"));
8080       arm_sec->rela = NULL;
8081       arm_sec->nrelas = 0;
8082
8083       for (relsec = section_headers;
8084            relsec < section_headers + elf_header.e_shnum;
8085            ++relsec)
8086         {
8087           if (relsec->sh_info >= elf_header.e_shnum
8088               || section_headers + relsec->sh_info != sec
8089               /* PR 15745: Check the section type as well.  */
8090               || (relsec->sh_type != SHT_REL
8091                   && relsec->sh_type != SHT_RELA))
8092             continue;
8093
8094           arm_sec->rel_type = relsec->sh_type;
8095           if (relsec->sh_type == SHT_REL)
8096             {
8097               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8098                                      relsec->sh_size,
8099                                      & arm_sec->rela, & arm_sec->nrelas))
8100                 return FALSE;
8101             }
8102           else /* relsec->sh_type == SHT_RELA */
8103             {
8104               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8105                                       relsec->sh_size,
8106                                       & arm_sec->rela, & arm_sec->nrelas))
8107                 return FALSE;
8108             }
8109           break;
8110         }
8111
8112       arm_sec->next_rela = arm_sec->rela;
8113     }
8114
8115   /* If there is no unwind data we can do nothing.  */
8116   if (arm_sec->data == NULL)
8117     return FALSE;
8118
8119   /* If the offset is invalid then fail.  */
8120   if (/* PR 21343 *//* PR 18879 */
8121       sec->sh_size < 4
8122       || word_offset > (sec->sh_size - 4)
8123       || ((bfd_signed_vma) word_offset) < 0)
8124     return FALSE;
8125
8126   /* Get the word at the required offset.  */
8127   word = byte_get (arm_sec->data + word_offset, 4);
8128
8129   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8130   if (arm_sec->rela == NULL)
8131     {
8132       * wordp = word;
8133       return TRUE;
8134     }
8135
8136   /* Look through the relocs to find the one that applies to the provided offset.  */
8137   wrapped = FALSE;
8138   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8139     {
8140       bfd_vma prelval, offset;
8141
8142       if (rp->r_offset > word_offset && !wrapped)
8143         {
8144           rp = arm_sec->rela;
8145           wrapped = TRUE;
8146         }
8147       if (rp->r_offset > word_offset)
8148         break;
8149
8150       if (rp->r_offset & 3)
8151         {
8152           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8153                 (unsigned long) rp->r_offset);
8154           continue;
8155         }
8156
8157       if (rp->r_offset < word_offset)
8158         continue;
8159
8160       /* PR 17531: file: 027-161405-0.004  */
8161       if (aux->symtab == NULL)
8162         continue;
8163
8164       if (arm_sec->rel_type == SHT_REL)
8165         {
8166           offset = word & 0x7fffffff;
8167           if (offset & 0x40000000)
8168             offset |= ~ (bfd_vma) 0x7fffffff;
8169         }
8170       else if (arm_sec->rel_type == SHT_RELA)
8171         offset = rp->r_addend;
8172       else
8173         {
8174           error (_("Unknown section relocation type %d encountered\n"),
8175                  arm_sec->rel_type);
8176           break;
8177         }
8178
8179       /* PR 17531 file: 027-1241568-0.004.  */
8180       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8181         {
8182           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8183                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8184           break;
8185         }
8186
8187       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8188       offset += sym->st_value;
8189       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8190
8191       /* Check that we are processing the expected reloc type.  */
8192       if (elf_header.e_machine == EM_ARM)
8193         {
8194           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8195           if (relname == NULL)
8196             {
8197               warn (_("Skipping unknown ARM relocation type: %d\n"),
8198                     (int) ELF32_R_TYPE (rp->r_info));
8199               continue;
8200             }
8201
8202           if (streq (relname, "R_ARM_NONE"))
8203               continue;
8204
8205           if (! streq (relname, "R_ARM_PREL31"))
8206             {
8207               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8208               continue;
8209             }
8210         }
8211       else if (elf_header.e_machine == EM_TI_C6000)
8212         {
8213           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8214           if (relname == NULL)
8215             {
8216               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8217                     (int) ELF32_R_TYPE (rp->r_info));
8218               continue;
8219             }
8220
8221           if (streq (relname, "R_C6000_NONE"))
8222             continue;
8223
8224           if (! streq (relname, "R_C6000_PREL31"))
8225             {
8226               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8227               continue;
8228             }
8229
8230           prelval >>= 1;
8231         }
8232       else
8233         {
8234           /* This function currently only supports ARM and TI unwinders.  */
8235           warn (_("Only TI and ARM unwinders are currently supported\n"));
8236           break;
8237         }
8238
8239       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8240       addr->section = sym->st_shndx;
8241       addr->offset = offset;
8242
8243       if (sym_name)
8244         * sym_name = sym->st_name;
8245       break;
8246     }
8247
8248   *wordp = word;
8249   arm_sec->next_rela = rp;
8250
8251   return TRUE;
8252 }
8253
8254 static const char *tic6x_unwind_regnames[16] =
8255 {
8256   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8257   "A14", "A13", "A12", "A11", "A10",
8258   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8259 };
8260
8261 static void
8262 decode_tic6x_unwind_regmask (unsigned int mask)
8263 {
8264   int i;
8265
8266   for (i = 12; mask; mask >>= 1, i--)
8267     {
8268       if (mask & 1)
8269         {
8270           fputs (tic6x_unwind_regnames[i], stdout);
8271           if (mask > 1)
8272             fputs (", ", stdout);
8273         }
8274     }
8275 }
8276
8277 #define ADVANCE                                                 \
8278   if (remaining == 0 && more_words)                             \
8279     {                                                           \
8280       data_offset += 4;                                         \
8281       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8282                                      data_offset, & word, & addr, NULL))        \
8283         return FALSE;                                           \
8284       remaining = 4;                                            \
8285       more_words--;                                             \
8286     }                                                           \
8287
8288 #define GET_OP(OP)                      \
8289   ADVANCE;                              \
8290   if (remaining)                        \
8291     {                                   \
8292       remaining--;                      \
8293       (OP) = word >> 24;                \
8294       word <<= 8;                       \
8295     }                                   \
8296   else                                  \
8297     {                                   \
8298       printf (_("[Truncated opcode]\n"));       \
8299       return FALSE;                     \
8300     }                                   \
8301   printf ("0x%02x ", OP)
8302
8303 static bfd_boolean
8304 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8305                             unsigned int               word,
8306                             unsigned int               remaining,
8307                             unsigned int               more_words,
8308                             bfd_vma                    data_offset,
8309                             Elf_Internal_Shdr *        data_sec,
8310                             struct arm_section *       data_arm_sec)
8311 {
8312   struct absaddr addr;
8313   bfd_boolean res = TRUE;
8314
8315   /* Decode the unwinding instructions.  */
8316   while (1)
8317     {
8318       unsigned int op, op2;
8319
8320       ADVANCE;
8321       if (remaining == 0)
8322         break;
8323       remaining--;
8324       op = word >> 24;
8325       word <<= 8;
8326
8327       printf ("  0x%02x ", op);
8328
8329       if ((op & 0xc0) == 0x00)
8330         {
8331           int offset = ((op & 0x3f) << 2) + 4;
8332
8333           printf ("     vsp = vsp + %d", offset);
8334         }
8335       else if ((op & 0xc0) == 0x40)
8336         {
8337           int offset = ((op & 0x3f) << 2) + 4;
8338
8339           printf ("     vsp = vsp - %d", offset);
8340         }
8341       else if ((op & 0xf0) == 0x80)
8342         {
8343           GET_OP (op2);
8344           if (op == 0x80 && op2 == 0)
8345             printf (_("Refuse to unwind"));
8346           else
8347             {
8348               unsigned int mask = ((op & 0x0f) << 8) | op2;
8349               bfd_boolean first = TRUE;
8350               int i;
8351
8352               printf ("pop {");
8353               for (i = 0; i < 12; i++)
8354                 if (mask & (1 << i))
8355                   {
8356                     if (first)
8357                       first = FALSE;
8358                     else
8359                       printf (", ");
8360                     printf ("r%d", 4 + i);
8361                   }
8362               printf ("}");
8363             }
8364         }
8365       else if ((op & 0xf0) == 0x90)
8366         {
8367           if (op == 0x9d || op == 0x9f)
8368             printf (_("     [Reserved]"));
8369           else
8370             printf ("     vsp = r%d", op & 0x0f);
8371         }
8372       else if ((op & 0xf0) == 0xa0)
8373         {
8374           int end = 4 + (op & 0x07);
8375           bfd_boolean first = TRUE;
8376           int i;
8377
8378           printf ("     pop {");
8379           for (i = 4; i <= end; i++)
8380             {
8381               if (first)
8382                 first = FALSE;
8383               else
8384                 printf (", ");
8385               printf ("r%d", i);
8386             }
8387           if (op & 0x08)
8388             {
8389               if (!first)
8390                 printf (", ");
8391               printf ("r14");
8392             }
8393           printf ("}");
8394         }
8395       else if (op == 0xb0)
8396         printf (_("     finish"));
8397       else if (op == 0xb1)
8398         {
8399           GET_OP (op2);
8400           if (op2 == 0 || (op2 & 0xf0) != 0)
8401             printf (_("[Spare]"));
8402           else
8403             {
8404               unsigned int mask = op2 & 0x0f;
8405               bfd_boolean first = TRUE;
8406               int i;
8407
8408               printf ("pop {");
8409               for (i = 0; i < 12; i++)
8410                 if (mask & (1 << i))
8411                   {
8412                     if (first)
8413                       first = FALSE;
8414                     else
8415                       printf (", ");
8416                     printf ("r%d", i);
8417                   }
8418               printf ("}");
8419             }
8420         }
8421       else if (op == 0xb2)
8422         {
8423           unsigned char buf[9];
8424           unsigned int i, len;
8425           unsigned long offset;
8426
8427           for (i = 0; i < sizeof (buf); i++)
8428             {
8429               GET_OP (buf[i]);
8430               if ((buf[i] & 0x80) == 0)
8431                 break;
8432             }
8433           if (i == sizeof (buf))
8434             {
8435               error (_("corrupt change to vsp"));
8436               res = FALSE;
8437             }
8438           else
8439             {
8440               offset = read_uleb128 (buf, &len, buf + i + 1);
8441               assert (len == i + 1);
8442               offset = offset * 4 + 0x204;
8443               printf ("vsp = vsp + %ld", offset);
8444             }
8445         }
8446       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8447         {
8448           unsigned int first, last;
8449
8450           GET_OP (op2);
8451           first = op2 >> 4;
8452           last = op2 & 0x0f;
8453           if (op == 0xc8)
8454             first = first + 16;
8455           printf ("pop {D%d", first);
8456           if (last)
8457             printf ("-D%d", first + last);
8458           printf ("}");
8459         }
8460       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8461         {
8462           unsigned int count = op & 0x07;
8463
8464           printf ("pop {D8");
8465           if (count)
8466             printf ("-D%d", 8 + count);
8467           printf ("}");
8468         }
8469       else if (op >= 0xc0 && op <= 0xc5)
8470         {
8471           unsigned int count = op & 0x07;
8472
8473           printf ("     pop {wR10");
8474           if (count)
8475             printf ("-wR%d", 10 + count);
8476           printf ("}");
8477         }
8478       else if (op == 0xc6)
8479         {
8480           unsigned int first, last;
8481
8482           GET_OP (op2);
8483           first = op2 >> 4;
8484           last = op2 & 0x0f;
8485           printf ("pop {wR%d", first);
8486           if (last)
8487             printf ("-wR%d", first + last);
8488           printf ("}");
8489         }
8490       else if (op == 0xc7)
8491         {
8492           GET_OP (op2);
8493           if (op2 == 0 || (op2 & 0xf0) != 0)
8494             printf (_("[Spare]"));
8495           else
8496             {
8497               unsigned int mask = op2 & 0x0f;
8498               bfd_boolean first = TRUE;
8499               int i;
8500
8501               printf ("pop {");
8502               for (i = 0; i < 4; i++)
8503                 if (mask & (1 << i))
8504                   {
8505                     if (first)
8506                       first = FALSE;
8507                     else
8508                       printf (", ");
8509                     printf ("wCGR%d", i);
8510                   }
8511               printf ("}");
8512             }
8513         }
8514       else
8515         {
8516           printf (_("     [unsupported opcode]"));
8517           res = FALSE;
8518         }
8519
8520       printf ("\n");
8521     }
8522
8523   return res;
8524 }
8525
8526 static bfd_boolean
8527 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8528                               unsigned int               word,
8529                               unsigned int               remaining,
8530                               unsigned int               more_words,
8531                               bfd_vma                    data_offset,
8532                               Elf_Internal_Shdr *        data_sec,
8533                               struct arm_section *       data_arm_sec)
8534 {
8535   struct absaddr addr;
8536
8537   /* Decode the unwinding instructions.  */
8538   while (1)
8539     {
8540       unsigned int op, op2;
8541
8542       ADVANCE;
8543       if (remaining == 0)
8544         break;
8545       remaining--;
8546       op = word >> 24;
8547       word <<= 8;
8548
8549       printf ("  0x%02x ", op);
8550
8551       if ((op & 0xc0) == 0x00)
8552         {
8553           int offset = ((op & 0x3f) << 3) + 8;
8554           printf ("     sp = sp + %d", offset);
8555         }
8556       else if ((op & 0xc0) == 0x80)
8557         {
8558           GET_OP (op2);
8559           if (op == 0x80 && op2 == 0)
8560             printf (_("Refuse to unwind"));
8561           else
8562             {
8563               unsigned int mask = ((op & 0x1f) << 8) | op2;
8564               if (op & 0x20)
8565                 printf ("pop compact {");
8566               else
8567                 printf ("pop {");
8568
8569               decode_tic6x_unwind_regmask (mask);
8570               printf("}");
8571             }
8572         }
8573       else if ((op & 0xf0) == 0xc0)
8574         {
8575           unsigned int reg;
8576           unsigned int nregs;
8577           unsigned int i;
8578           const char *name;
8579           struct
8580           {
8581             unsigned int offset;
8582             unsigned int reg;
8583           } regpos[16];
8584
8585           /* Scan entire instruction first so that GET_OP output is not
8586              interleaved with disassembly.  */
8587           nregs = 0;
8588           for (i = 0; nregs < (op & 0xf); i++)
8589             {
8590               GET_OP (op2);
8591               reg = op2 >> 4;
8592               if (reg != 0xf)
8593                 {
8594                   regpos[nregs].offset = i * 2;
8595                   regpos[nregs].reg = reg;
8596                   nregs++;
8597                 }
8598
8599               reg = op2 & 0xf;
8600               if (reg != 0xf)
8601                 {
8602                   regpos[nregs].offset = i * 2 + 1;
8603                   regpos[nregs].reg = reg;
8604                   nregs++;
8605                 }
8606             }
8607
8608           printf (_("pop frame {"));
8609           reg = nregs - 1;
8610           for (i = i * 2; i > 0; i--)
8611             {
8612               if (regpos[reg].offset == i - 1)
8613                 {
8614                   name = tic6x_unwind_regnames[regpos[reg].reg];
8615                   if (reg > 0)
8616                     reg--;
8617                 }
8618               else
8619                 name = _("[pad]");
8620
8621               fputs (name, stdout);
8622               if (i > 1)
8623                 printf (", ");
8624             }
8625
8626           printf ("}");
8627         }
8628       else if (op == 0xd0)
8629         printf ("     MOV FP, SP");
8630       else if (op == 0xd1)
8631         printf ("     __c6xabi_pop_rts");
8632       else if (op == 0xd2)
8633         {
8634           unsigned char buf[9];
8635           unsigned int i, len;
8636           unsigned long offset;
8637
8638           for (i = 0; i < sizeof (buf); i++)
8639             {
8640               GET_OP (buf[i]);
8641               if ((buf[i] & 0x80) == 0)
8642                 break;
8643             }
8644           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8645           if (i == sizeof (buf))
8646             {
8647               warn (_("Corrupt stack pointer adjustment detected\n"));
8648               return FALSE;
8649             }
8650
8651           offset = read_uleb128 (buf, &len, buf + i + 1);
8652           assert (len == i + 1);
8653           offset = offset * 8 + 0x408;
8654           printf (_("sp = sp + %ld"), offset);
8655         }
8656       else if ((op & 0xf0) == 0xe0)
8657         {
8658           if ((op & 0x0f) == 7)
8659             printf ("     RETURN");
8660           else
8661             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8662         }
8663       else
8664         {
8665           printf (_("     [unsupported opcode]"));
8666         }
8667       putchar ('\n');
8668     }
8669
8670   return TRUE;
8671 }
8672
8673 static bfd_vma
8674 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8675 {
8676   bfd_vma offset;
8677
8678   offset = word & 0x7fffffff;
8679   if (offset & 0x40000000)
8680     offset |= ~ (bfd_vma) 0x7fffffff;
8681
8682   if (elf_header.e_machine == EM_TI_C6000)
8683     offset <<= 1;
8684
8685   return offset + where;
8686 }
8687
8688 static bfd_boolean
8689 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8690                    unsigned int               word,
8691                    unsigned int               remaining,
8692                    bfd_vma                    data_offset,
8693                    Elf_Internal_Shdr *        data_sec,
8694                    struct arm_section *       data_arm_sec)
8695 {
8696   int per_index;
8697   unsigned int more_words = 0;
8698   struct absaddr addr;
8699   bfd_vma sym_name = (bfd_vma) -1;
8700   bfd_boolean res = FALSE;
8701
8702   if (remaining == 0)
8703     {
8704       /* Fetch the first word.
8705          Note - when decoding an object file the address extracted
8706          here will always be 0.  So we also pass in the sym_name
8707          parameter so that we can find the symbol associated with
8708          the personality routine.  */
8709       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8710                                      & word, & addr, & sym_name))
8711         return FALSE;
8712
8713       remaining = 4;
8714     }
8715
8716   if ((word & 0x80000000) == 0)
8717     {
8718       /* Expand prel31 for personality routine.  */
8719       bfd_vma fn;
8720       const char *procname;
8721
8722       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8723       printf (_("  Personality routine: "));
8724       if (fn == 0
8725           && addr.section == SHN_UNDEF && addr.offset == 0
8726           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8727         {
8728           procname = aux->strtab + sym_name;
8729           print_vma (fn, PREFIX_HEX);
8730           if (procname)
8731             {
8732               fputs (" <", stdout);
8733               fputs (procname, stdout);
8734               fputc ('>', stdout);
8735             }
8736         }
8737       else
8738         procname = arm_print_vma_and_name (aux, fn, addr);
8739       fputc ('\n', stdout);
8740
8741       /* The GCC personality routines use the standard compact
8742          encoding, starting with one byte giving the number of
8743          words.  */
8744       if (procname != NULL
8745           && (const_strneq (procname, "__gcc_personality_v0")
8746               || const_strneq (procname, "__gxx_personality_v0")
8747               || const_strneq (procname, "__gcj_personality_v0")
8748               || const_strneq (procname, "__gnu_objc_personality_v0")))
8749         {
8750           remaining = 0;
8751           more_words = 1;
8752           ADVANCE;
8753           if (!remaining)
8754             {
8755               printf (_("  [Truncated data]\n"));
8756               return FALSE;
8757             }
8758           more_words = word >> 24;
8759           word <<= 8;
8760           remaining--;
8761           per_index = -1;
8762         }
8763       else
8764         return TRUE;
8765     }
8766   else
8767     {
8768       /* ARM EHABI Section 6.3:
8769
8770          An exception-handling table entry for the compact model looks like:
8771
8772            31 30-28 27-24 23-0
8773            -- ----- ----- ----
8774             1   0   index Data for personalityRoutine[index]    */
8775
8776       if (elf_header.e_machine == EM_ARM
8777           && (word & 0x70000000))
8778         {
8779           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8780           res = FALSE;
8781         }
8782
8783       per_index = (word >> 24) & 0x7f;
8784       printf (_("  Compact model index: %d\n"), per_index);
8785       if (per_index == 0)
8786         {
8787           more_words = 0;
8788           word <<= 8;
8789           remaining--;
8790         }
8791       else if (per_index < 3)
8792         {
8793           more_words = (word >> 16) & 0xff;
8794           word <<= 16;
8795           remaining -= 2;
8796         }
8797     }
8798
8799   switch (elf_header.e_machine)
8800     {
8801     case EM_ARM:
8802       if (per_index < 3)
8803         {
8804           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8805                                             data_offset, data_sec, data_arm_sec))
8806             res = FALSE;
8807         }
8808       else
8809         {
8810           warn (_("Unknown ARM compact model index encountered\n"));
8811           printf (_("  [reserved]\n"));
8812           res = FALSE;
8813         }
8814       break;
8815
8816     case EM_TI_C6000:
8817       if (per_index < 3)
8818         {
8819           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8820                                               data_offset, data_sec, data_arm_sec))
8821             res = FALSE;
8822         }
8823       else if (per_index < 5)
8824         {
8825           if (((word >> 17) & 0x7f) == 0x7f)
8826             printf (_("  Restore stack from frame pointer\n"));
8827           else
8828             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8829           printf (_("  Registers restored: "));
8830           if (per_index == 4)
8831             printf (" (compact) ");
8832           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8833           putchar ('\n');
8834           printf (_("  Return register: %s\n"),
8835                   tic6x_unwind_regnames[word & 0xf]);
8836         }
8837       else
8838         printf (_("  [reserved (%d)]\n"), per_index);
8839       break;
8840
8841     default:
8842       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8843              elf_header.e_machine);
8844       res = FALSE;
8845     }
8846
8847   /* Decode the descriptors.  Not implemented.  */
8848
8849   return res;
8850 }
8851
8852 static bfd_boolean
8853 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8854 {
8855   struct arm_section exidx_arm_sec, extab_arm_sec;
8856   unsigned int i, exidx_len;
8857   unsigned long j, nfuns;
8858   bfd_boolean res = TRUE;
8859
8860   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8861   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8862   exidx_len = exidx_sec->sh_size / 8;
8863
8864   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8865   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8866     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8867       aux->funtab[nfuns++] = aux->symtab[j];
8868   aux->nfuns = nfuns;
8869   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8870
8871   for (i = 0; i < exidx_len; i++)
8872     {
8873       unsigned int exidx_fn, exidx_entry;
8874       struct absaddr fn_addr, entry_addr;
8875       bfd_vma fn;
8876
8877       fputc ('\n', stdout);
8878
8879       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8880                                      8 * i, & exidx_fn, & fn_addr, NULL)
8881           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8882                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8883         {
8884           free (aux->funtab);
8885           arm_free_section (& exidx_arm_sec);
8886           arm_free_section (& extab_arm_sec);
8887           return FALSE;
8888         }
8889
8890       /* ARM EHABI, Section 5:
8891          An index table entry consists of 2 words.
8892          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8893       if (exidx_fn & 0x80000000)
8894         {
8895           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8896           res = FALSE;
8897         }
8898
8899       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8900
8901       arm_print_vma_and_name (aux, fn, fn_addr);
8902       fputs (": ", stdout);
8903
8904       if (exidx_entry == 1)
8905         {
8906           print_vma (exidx_entry, PREFIX_HEX);
8907           fputs (" [cantunwind]\n", stdout);
8908         }
8909       else if (exidx_entry & 0x80000000)
8910         {
8911           print_vma (exidx_entry, PREFIX_HEX);
8912           fputc ('\n', stdout);
8913           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8914         }
8915       else
8916         {
8917           bfd_vma table, table_offset = 0;
8918           Elf_Internal_Shdr *table_sec;
8919
8920           fputs ("@", stdout);
8921           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8922           print_vma (table, PREFIX_HEX);
8923           printf ("\n");
8924
8925           /* Locate the matching .ARM.extab.  */
8926           if (entry_addr.section != SHN_UNDEF
8927               && entry_addr.section < elf_header.e_shnum)
8928             {
8929               table_sec = section_headers + entry_addr.section;
8930               table_offset = entry_addr.offset;
8931               /* PR 18879 */
8932               if (table_offset > table_sec->sh_size
8933                   || ((bfd_signed_vma) table_offset) < 0)
8934                 {
8935                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8936                         (unsigned long) table_offset,
8937                         printable_section_name (table_sec));
8938                   res = FALSE;
8939                   continue;
8940                 }
8941             }
8942           else
8943             {
8944               table_sec = find_section_by_address (table);
8945               if (table_sec != NULL)
8946                 table_offset = table - table_sec->sh_addr;
8947             }
8948
8949           if (table_sec == NULL)
8950             {
8951               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8952                     (unsigned long) table);
8953               res = FALSE;
8954               continue;
8955             }
8956
8957           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8958                                    &extab_arm_sec))
8959             res = FALSE;
8960         }
8961     }
8962
8963   printf ("\n");
8964
8965   free (aux->funtab);
8966   arm_free_section (&exidx_arm_sec);
8967   arm_free_section (&extab_arm_sec);
8968
8969   return res;
8970 }
8971
8972 /* Used for both ARM and C6X unwinding tables.  */
8973
8974 static bfd_boolean
8975 arm_process_unwind (FILE *file)
8976 {
8977   struct arm_unw_aux_info aux;
8978   Elf_Internal_Shdr *unwsec = NULL;
8979   Elf_Internal_Shdr *strsec;
8980   Elf_Internal_Shdr *sec;
8981   unsigned long i;
8982   unsigned int sec_type;
8983   bfd_boolean res = TRUE;
8984
8985   switch (elf_header.e_machine)
8986     {
8987     case EM_ARM:
8988       sec_type = SHT_ARM_EXIDX;
8989       break;
8990
8991     case EM_TI_C6000:
8992       sec_type = SHT_C6000_UNWIND;
8993       break;
8994
8995     default:
8996       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8997              elf_header.e_machine);
8998       return FALSE;
8999     }
9000
9001   if (string_table == NULL)
9002     return FALSE;
9003
9004   memset (& aux, 0, sizeof (aux));
9005   aux.file = file;
9006
9007   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9008     {
9009       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9010         {
9011           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9012
9013           strsec = section_headers + sec->sh_link;
9014
9015           /* PR binutils/17531 file: 011-12666-0.004.  */
9016           if (aux.strtab != NULL)
9017             {
9018               error (_("Multiple string tables found in file.\n"));
9019               free (aux.strtab);
9020               res = FALSE;
9021             }
9022           aux.strtab = get_data (NULL, file, strsec->sh_offset,
9023                                  1, strsec->sh_size, _("string table"));
9024           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9025         }
9026       else if (sec->sh_type == sec_type)
9027         unwsec = sec;
9028     }
9029
9030   if (unwsec == NULL)
9031     printf (_("\nThere are no unwind sections in this file.\n"));
9032   else
9033     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9034       {
9035         if (sec->sh_type == sec_type)
9036           {
9037             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9038                     printable_section_name (sec),
9039                     (unsigned long) sec->sh_offset,
9040                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9041
9042             if (! dump_arm_unwind (&aux, sec))
9043               res = FALSE;
9044           }
9045       }
9046
9047   if (aux.symtab)
9048     free (aux.symtab);
9049   if (aux.strtab)
9050     free ((char *) aux.strtab);
9051
9052   return res;
9053 }
9054
9055 static bfd_boolean
9056 process_unwind (FILE * file)
9057 {
9058   struct unwind_handler
9059   {
9060     unsigned int machtype;
9061     bfd_boolean (* handler)(FILE *);
9062   } handlers[] =
9063   {
9064     { EM_ARM, arm_process_unwind },
9065     { EM_IA_64, ia64_process_unwind },
9066     { EM_PARISC, hppa_process_unwind },
9067     { EM_TI_C6000, arm_process_unwind },
9068     { 0, NULL }
9069   };
9070   int i;
9071
9072   if (!do_unwind)
9073     return TRUE;
9074
9075   for (i = 0; handlers[i].handler != NULL; i++)
9076     if (elf_header.e_machine == handlers[i].machtype)
9077       return handlers[i].handler (file);
9078
9079   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9080           get_machine_name (elf_header.e_machine));
9081   return TRUE;
9082 }
9083
9084 static void
9085 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9086 {
9087   switch (entry->d_tag)
9088     {
9089     case DT_MIPS_FLAGS:
9090       if (entry->d_un.d_val == 0)
9091         printf (_("NONE"));
9092       else
9093         {
9094           static const char * opts[] =
9095           {
9096             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9097             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9098             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9099             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9100             "RLD_ORDER_SAFE"
9101           };
9102           unsigned int cnt;
9103           bfd_boolean first = TRUE;
9104
9105           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9106             if (entry->d_un.d_val & (1 << cnt))
9107               {
9108                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9109                 first = FALSE;
9110               }
9111         }
9112       break;
9113
9114     case DT_MIPS_IVERSION:
9115       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9116         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9117       else
9118         {
9119           char buf[40];
9120           sprintf_vma (buf, entry->d_un.d_ptr);
9121           /* Note: coded this way so that there is a single string for translation.  */
9122           printf (_("<corrupt: %s>"), buf);
9123         }
9124       break;
9125
9126     case DT_MIPS_TIME_STAMP:
9127       {
9128         char timebuf[128];
9129         struct tm * tmp;
9130         time_t atime = entry->d_un.d_val;
9131
9132         tmp = gmtime (&atime);
9133         /* PR 17531: file: 6accc532.  */
9134         if (tmp == NULL)
9135           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9136         else
9137           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9138                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9139                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9140         printf (_("Time Stamp: %s"), timebuf);
9141       }
9142       break;
9143
9144     case DT_MIPS_RLD_VERSION:
9145     case DT_MIPS_LOCAL_GOTNO:
9146     case DT_MIPS_CONFLICTNO:
9147     case DT_MIPS_LIBLISTNO:
9148     case DT_MIPS_SYMTABNO:
9149     case DT_MIPS_UNREFEXTNO:
9150     case DT_MIPS_HIPAGENO:
9151     case DT_MIPS_DELTA_CLASS_NO:
9152     case DT_MIPS_DELTA_INSTANCE_NO:
9153     case DT_MIPS_DELTA_RELOC_NO:
9154     case DT_MIPS_DELTA_SYM_NO:
9155     case DT_MIPS_DELTA_CLASSSYM_NO:
9156     case DT_MIPS_COMPACT_SIZE:
9157       print_vma (entry->d_un.d_val, DEC);
9158       break;
9159
9160     default:
9161       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9162     }
9163     putchar ('\n');
9164 }
9165
9166 static void
9167 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9168 {
9169   switch (entry->d_tag)
9170     {
9171     case DT_HP_DLD_FLAGS:
9172       {
9173         static struct
9174         {
9175           long int bit;
9176           const char * str;
9177         }
9178         flags[] =
9179         {
9180           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9181           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9182           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9183           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9184           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9185           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9186           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9187           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9188           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9189           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9190           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9191           { DT_HP_GST, "HP_GST" },
9192           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9193           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9194           { DT_HP_NODELETE, "HP_NODELETE" },
9195           { DT_HP_GROUP, "HP_GROUP" },
9196           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9197         };
9198         bfd_boolean first = TRUE;
9199         size_t cnt;
9200         bfd_vma val = entry->d_un.d_val;
9201
9202         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9203           if (val & flags[cnt].bit)
9204             {
9205               if (! first)
9206                 putchar (' ');
9207               fputs (flags[cnt].str, stdout);
9208               first = FALSE;
9209               val ^= flags[cnt].bit;
9210             }
9211
9212         if (val != 0 || first)
9213           {
9214             if (! first)
9215               putchar (' ');
9216             print_vma (val, HEX);
9217           }
9218       }
9219       break;
9220
9221     default:
9222       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9223       break;
9224     }
9225   putchar ('\n');
9226 }
9227
9228 #ifdef BFD64
9229
9230 /* VMS vs Unix time offset and factor.  */
9231
9232 #define VMS_EPOCH_OFFSET 35067168000000000LL
9233 #define VMS_GRANULARITY_FACTOR 10000000
9234
9235 /* Display a VMS time in a human readable format.  */
9236
9237 static void
9238 print_vms_time (bfd_int64_t vmstime)
9239 {
9240   struct tm *tm;
9241   time_t unxtime;
9242
9243   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9244   tm = gmtime (&unxtime);
9245   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9246           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9247           tm->tm_hour, tm->tm_min, tm->tm_sec);
9248 }
9249 #endif /* BFD64 */
9250
9251 static void
9252 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9253 {
9254   switch (entry->d_tag)
9255     {
9256     case DT_IA_64_PLT_RESERVE:
9257       /* First 3 slots reserved.  */
9258       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9259       printf (" -- ");
9260       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9261       break;
9262
9263     case DT_IA_64_VMS_LINKTIME:
9264 #ifdef BFD64
9265       print_vms_time (entry->d_un.d_val);
9266 #endif
9267       break;
9268
9269     case DT_IA_64_VMS_LNKFLAGS:
9270       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9271       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9272         printf (" CALL_DEBUG");
9273       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9274         printf (" NOP0BUFS");
9275       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9276         printf (" P0IMAGE");
9277       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9278         printf (" MKTHREADS");
9279       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9280         printf (" UPCALLS");
9281       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9282         printf (" IMGSTA");
9283       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9284         printf (" INITIALIZE");
9285       if (entry->d_un.d_val & VMS_LF_MAIN)
9286         printf (" MAIN");
9287       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9288         printf (" EXE_INIT");
9289       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9290         printf (" TBK_IN_IMG");
9291       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9292         printf (" DBG_IN_IMG");
9293       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9294         printf (" TBK_IN_DSF");
9295       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9296         printf (" DBG_IN_DSF");
9297       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9298         printf (" SIGNATURES");
9299       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9300         printf (" REL_SEG_OFF");
9301       break;
9302
9303     default:
9304       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9305       break;
9306     }
9307   putchar ('\n');
9308 }
9309
9310 static bfd_boolean
9311 get_32bit_dynamic_section (FILE * file)
9312 {
9313   Elf32_External_Dyn * edyn;
9314   Elf32_External_Dyn * ext;
9315   Elf_Internal_Dyn * entry;
9316
9317   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9318                                           dynamic_size, _("dynamic section"));
9319   if (!edyn)
9320     return FALSE;
9321
9322   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9323      might not have the luxury of section headers.  Look for the DT_NULL
9324      terminator to determine the number of entries.  */
9325   for (ext = edyn, dynamic_nent = 0;
9326        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9327        ext++)
9328     {
9329       dynamic_nent++;
9330       if (BYTE_GET (ext->d_tag) == DT_NULL)
9331         break;
9332     }
9333
9334   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9335                                                   sizeof (* entry));
9336   if (dynamic_section == NULL)
9337     {
9338       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9339              (unsigned long) dynamic_nent);
9340       free (edyn);
9341       return FALSE;
9342     }
9343
9344   for (ext = edyn, entry = dynamic_section;
9345        entry < dynamic_section + dynamic_nent;
9346        ext++, entry++)
9347     {
9348       entry->d_tag      = BYTE_GET (ext->d_tag);
9349       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9350     }
9351
9352   free (edyn);
9353
9354   return TRUE;
9355 }
9356
9357 static bfd_boolean
9358 get_64bit_dynamic_section (FILE * file)
9359 {
9360   Elf64_External_Dyn * edyn;
9361   Elf64_External_Dyn * ext;
9362   Elf_Internal_Dyn * entry;
9363
9364   /* Read in the data.  */
9365   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9366                                           dynamic_size, _("dynamic section"));
9367   if (!edyn)
9368     return FALSE;
9369
9370   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9371      might not have the luxury of section headers.  Look for the DT_NULL
9372      terminator to determine the number of entries.  */
9373   for (ext = edyn, dynamic_nent = 0;
9374        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9375        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9376        ext++)
9377     {
9378       dynamic_nent++;
9379       if (BYTE_GET (ext->d_tag) == DT_NULL)
9380         break;
9381     }
9382
9383   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9384                                                   sizeof (* entry));
9385   if (dynamic_section == NULL)
9386     {
9387       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9388              (unsigned long) dynamic_nent);
9389       free (edyn);
9390       return FALSE;
9391     }
9392
9393   /* Convert from external to internal formats.  */
9394   for (ext = edyn, entry = dynamic_section;
9395        entry < dynamic_section + dynamic_nent;
9396        ext++, entry++)
9397     {
9398       entry->d_tag      = BYTE_GET (ext->d_tag);
9399       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9400     }
9401
9402   free (edyn);
9403
9404   return TRUE;
9405 }
9406
9407 static void
9408 print_dynamic_flags (bfd_vma flags)
9409 {
9410   bfd_boolean first = TRUE;
9411
9412   while (flags)
9413     {
9414       bfd_vma flag;
9415
9416       flag = flags & - flags;
9417       flags &= ~ flag;
9418
9419       if (first)
9420         first = FALSE;
9421       else
9422         putc (' ', stdout);
9423
9424       switch (flag)
9425         {
9426         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9427         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9428         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9429         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9430         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9431         default:                fputs (_("unknown"), stdout); break;
9432         }
9433     }
9434   puts ("");
9435 }
9436
9437 /* Parse and display the contents of the dynamic section.  */
9438
9439 static bfd_boolean
9440 process_dynamic_section (FILE * file)
9441 {
9442   Elf_Internal_Dyn * entry;
9443
9444   if (dynamic_size == 0)
9445     {
9446       if (do_dynamic)
9447         printf (_("\nThere is no dynamic section in this file.\n"));
9448
9449       return TRUE;
9450     }
9451
9452   if (is_32bit_elf)
9453     {
9454       if (! get_32bit_dynamic_section (file))
9455         return FALSE;
9456     }
9457   else
9458     {
9459       if (! get_64bit_dynamic_section (file))
9460         return FALSE;
9461     }
9462
9463   /* Find the appropriate symbol table.  */
9464   if (dynamic_symbols == NULL)
9465     {
9466       for (entry = dynamic_section;
9467            entry < dynamic_section + dynamic_nent;
9468            ++entry)
9469         {
9470           Elf_Internal_Shdr section;
9471
9472           if (entry->d_tag != DT_SYMTAB)
9473             continue;
9474
9475           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9476
9477           /* Since we do not know how big the symbol table is,
9478              we default to reading in the entire file (!) and
9479              processing that.  This is overkill, I know, but it
9480              should work.  */
9481           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9482           if ((bfd_size_type) section.sh_offset > current_file_size)
9483             {
9484               /* See PR 21379 for a reproducer.  */
9485               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9486               return FALSE;
9487             }
9488
9489           if (archive_file_offset != 0)
9490             section.sh_size = archive_file_size - section.sh_offset;
9491           else
9492             {
9493               if (fseek (file, 0, SEEK_END))
9494                 error (_("Unable to seek to end of file!\n"));
9495
9496               section.sh_size = ftell (file) - section.sh_offset;
9497             }
9498
9499           if (is_32bit_elf)
9500             section.sh_entsize = sizeof (Elf32_External_Sym);
9501           else
9502             section.sh_entsize = sizeof (Elf64_External_Sym);
9503           section.sh_name = string_table_length;
9504
9505           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9506           if (num_dynamic_syms < 1)
9507             {
9508               error (_("Unable to determine the number of symbols to load\n"));
9509               continue;
9510             }
9511         }
9512     }
9513
9514   /* Similarly find a string table.  */
9515   if (dynamic_strings == NULL)
9516     {
9517       for (entry = dynamic_section;
9518            entry < dynamic_section + dynamic_nent;
9519            ++entry)
9520         {
9521           unsigned long offset;
9522           long str_tab_len;
9523
9524           if (entry->d_tag != DT_STRTAB)
9525             continue;
9526
9527           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9528
9529           /* Since we do not know how big the string table is,
9530              we default to reading in the entire file (!) and
9531              processing that.  This is overkill, I know, but it
9532              should work.  */
9533
9534           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9535
9536           if (archive_file_offset != 0)
9537             str_tab_len = archive_file_size - offset;
9538           else
9539             {
9540               if (fseek (file, 0, SEEK_END))
9541                 error (_("Unable to seek to end of file\n"));
9542               str_tab_len = ftell (file) - offset;
9543             }
9544
9545           if (str_tab_len < 1)
9546             {
9547               error
9548                 (_("Unable to determine the length of the dynamic string table\n"));
9549               continue;
9550             }
9551
9552           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9553                                                str_tab_len,
9554                                                _("dynamic string table"));
9555           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9556           break;
9557         }
9558     }
9559
9560   /* And find the syminfo section if available.  */
9561   if (dynamic_syminfo == NULL)
9562     {
9563       unsigned long syminsz = 0;
9564
9565       for (entry = dynamic_section;
9566            entry < dynamic_section + dynamic_nent;
9567            ++entry)
9568         {
9569           if (entry->d_tag == DT_SYMINENT)
9570             {
9571               /* Note: these braces are necessary to avoid a syntax
9572                  error from the SunOS4 C compiler.  */
9573               /* PR binutils/17531: A corrupt file can trigger this test.
9574                  So do not use an assert, instead generate an error message.  */
9575               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9576                 error (_("Bad value (%d) for SYMINENT entry\n"),
9577                        (int) entry->d_un.d_val);
9578             }
9579           else if (entry->d_tag == DT_SYMINSZ)
9580             syminsz = entry->d_un.d_val;
9581           else if (entry->d_tag == DT_SYMINFO)
9582             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9583                                                       syminsz);
9584         }
9585
9586       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9587         {
9588           Elf_External_Syminfo * extsyminfo;
9589           Elf_External_Syminfo * extsym;
9590           Elf_Internal_Syminfo * syminfo;
9591
9592           /* There is a syminfo section.  Read the data.  */
9593           extsyminfo = (Elf_External_Syminfo *)
9594               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9595                         _("symbol information"));
9596           if (!extsyminfo)
9597             return FALSE;
9598
9599           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9600           if (dynamic_syminfo == NULL)
9601             {
9602               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9603                      (unsigned long) syminsz);
9604               return FALSE;
9605             }
9606
9607           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9608           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9609                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9610                ++syminfo, ++extsym)
9611             {
9612               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9613               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9614             }
9615
9616           free (extsyminfo);
9617         }
9618     }
9619
9620   if (do_dynamic && dynamic_addr)
9621     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9622             dynamic_addr, (unsigned long) dynamic_nent);
9623   if (do_dynamic)
9624     printf (_("  Tag        Type                         Name/Value\n"));
9625
9626   for (entry = dynamic_section;
9627        entry < dynamic_section + dynamic_nent;
9628        entry++)
9629     {
9630       if (do_dynamic)
9631         {
9632           const char * dtype;
9633
9634           putchar (' ');
9635           print_vma (entry->d_tag, FULL_HEX);
9636           dtype = get_dynamic_type (entry->d_tag);
9637           printf (" (%s)%*s", dtype,
9638                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9639         }
9640
9641       switch (entry->d_tag)
9642         {
9643         case DT_FLAGS:
9644           if (do_dynamic)
9645             print_dynamic_flags (entry->d_un.d_val);
9646           break;
9647
9648         case DT_AUXILIARY:
9649         case DT_FILTER:
9650         case DT_CONFIG:
9651         case DT_DEPAUDIT:
9652         case DT_AUDIT:
9653           if (do_dynamic)
9654             {
9655               switch (entry->d_tag)
9656                 {
9657                 case DT_AUXILIARY:
9658                   printf (_("Auxiliary library"));
9659                   break;
9660
9661                 case DT_FILTER:
9662                   printf (_("Filter library"));
9663                   break;
9664
9665                 case DT_CONFIG:
9666                   printf (_("Configuration file"));
9667                   break;
9668
9669                 case DT_DEPAUDIT:
9670                   printf (_("Dependency audit library"));
9671                   break;
9672
9673                 case DT_AUDIT:
9674                   printf (_("Audit library"));
9675                   break;
9676                 }
9677
9678               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9679                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9680               else
9681                 {
9682                   printf (": ");
9683                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9684                   putchar ('\n');
9685                 }
9686             }
9687           break;
9688
9689         case DT_FEATURE:
9690           if (do_dynamic)
9691             {
9692               printf (_("Flags:"));
9693
9694               if (entry->d_un.d_val == 0)
9695                 printf (_(" None\n"));
9696               else
9697                 {
9698                   unsigned long int val = entry->d_un.d_val;
9699
9700                   if (val & DTF_1_PARINIT)
9701                     {
9702                       printf (" PARINIT");
9703                       val ^= DTF_1_PARINIT;
9704                     }
9705                   if (val & DTF_1_CONFEXP)
9706                     {
9707                       printf (" CONFEXP");
9708                       val ^= DTF_1_CONFEXP;
9709                     }
9710                   if (val != 0)
9711                     printf (" %lx", val);
9712                   puts ("");
9713                 }
9714             }
9715           break;
9716
9717         case DT_POSFLAG_1:
9718           if (do_dynamic)
9719             {
9720               printf (_("Flags:"));
9721
9722               if (entry->d_un.d_val == 0)
9723                 printf (_(" None\n"));
9724               else
9725                 {
9726                   unsigned long int val = entry->d_un.d_val;
9727
9728                   if (val & DF_P1_LAZYLOAD)
9729                     {
9730                       printf (" LAZYLOAD");
9731                       val ^= DF_P1_LAZYLOAD;
9732                     }
9733                   if (val & DF_P1_GROUPPERM)
9734                     {
9735                       printf (" GROUPPERM");
9736                       val ^= DF_P1_GROUPPERM;
9737                     }
9738                   if (val != 0)
9739                     printf (" %lx", val);
9740                   puts ("");
9741                 }
9742             }
9743           break;
9744
9745         case DT_FLAGS_1:
9746           if (do_dynamic)
9747             {
9748               printf (_("Flags:"));
9749               if (entry->d_un.d_val == 0)
9750                 printf (_(" None\n"));
9751               else
9752                 {
9753                   unsigned long int val = entry->d_un.d_val;
9754
9755                   if (val & DF_1_NOW)
9756                     {
9757                       printf (" NOW");
9758                       val ^= DF_1_NOW;
9759                     }
9760                   if (val & DF_1_GLOBAL)
9761                     {
9762                       printf (" GLOBAL");
9763                       val ^= DF_1_GLOBAL;
9764                     }
9765                   if (val & DF_1_GROUP)
9766                     {
9767                       printf (" GROUP");
9768                       val ^= DF_1_GROUP;
9769                     }
9770                   if (val & DF_1_NODELETE)
9771                     {
9772                       printf (" NODELETE");
9773                       val ^= DF_1_NODELETE;
9774                     }
9775                   if (val & DF_1_LOADFLTR)
9776                     {
9777                       printf (" LOADFLTR");
9778                       val ^= DF_1_LOADFLTR;
9779                     }
9780                   if (val & DF_1_INITFIRST)
9781                     {
9782                       printf (" INITFIRST");
9783                       val ^= DF_1_INITFIRST;
9784                     }
9785                   if (val & DF_1_NOOPEN)
9786                     {
9787                       printf (" NOOPEN");
9788                       val ^= DF_1_NOOPEN;
9789                     }
9790                   if (val & DF_1_ORIGIN)
9791                     {
9792                       printf (" ORIGIN");
9793                       val ^= DF_1_ORIGIN;
9794                     }
9795                   if (val & DF_1_DIRECT)
9796                     {
9797                       printf (" DIRECT");
9798                       val ^= DF_1_DIRECT;
9799                     }
9800                   if (val & DF_1_TRANS)
9801                     {
9802                       printf (" TRANS");
9803                       val ^= DF_1_TRANS;
9804                     }
9805                   if (val & DF_1_INTERPOSE)
9806                     {
9807                       printf (" INTERPOSE");
9808                       val ^= DF_1_INTERPOSE;
9809                     }
9810                   if (val & DF_1_NODEFLIB)
9811                     {
9812                       printf (" NODEFLIB");
9813                       val ^= DF_1_NODEFLIB;
9814                     }
9815                   if (val & DF_1_NODUMP)
9816                     {
9817                       printf (" NODUMP");
9818                       val ^= DF_1_NODUMP;
9819                     }
9820                   if (val & DF_1_CONFALT)
9821                     {
9822                       printf (" CONFALT");
9823                       val ^= DF_1_CONFALT;
9824                     }
9825                   if (val & DF_1_ENDFILTEE)
9826                     {
9827                       printf (" ENDFILTEE");
9828                       val ^= DF_1_ENDFILTEE;
9829                     }
9830                   if (val & DF_1_DISPRELDNE)
9831                     {
9832                       printf (" DISPRELDNE");
9833                       val ^= DF_1_DISPRELDNE;
9834                     }
9835                   if (val & DF_1_DISPRELPND)
9836                     {
9837                       printf (" DISPRELPND");
9838                       val ^= DF_1_DISPRELPND;
9839                     }
9840                   if (val & DF_1_NODIRECT)
9841                     {
9842                       printf (" NODIRECT");
9843                       val ^= DF_1_NODIRECT;
9844                     }
9845                   if (val & DF_1_IGNMULDEF)
9846                     {
9847                       printf (" IGNMULDEF");
9848                       val ^= DF_1_IGNMULDEF;
9849                     }
9850                   if (val & DF_1_NOKSYMS)
9851                     {
9852                       printf (" NOKSYMS");
9853                       val ^= DF_1_NOKSYMS;
9854                     }
9855                   if (val & DF_1_NOHDR)
9856                     {
9857                       printf (" NOHDR");
9858                       val ^= DF_1_NOHDR;
9859                     }
9860                   if (val & DF_1_EDITED)
9861                     {
9862                       printf (" EDITED");
9863                       val ^= DF_1_EDITED;
9864                     }
9865                   if (val & DF_1_NORELOC)
9866                     {
9867                       printf (" NORELOC");
9868                       val ^= DF_1_NORELOC;
9869                     }
9870                   if (val & DF_1_SYMINTPOSE)
9871                     {
9872                       printf (" SYMINTPOSE");
9873                       val ^= DF_1_SYMINTPOSE;
9874                     }
9875                   if (val & DF_1_GLOBAUDIT)
9876                     {
9877                       printf (" GLOBAUDIT");
9878                       val ^= DF_1_GLOBAUDIT;
9879                     }
9880                   if (val & DF_1_SINGLETON)
9881                     {
9882                       printf (" SINGLETON");
9883                       val ^= DF_1_SINGLETON;
9884                     }
9885                   if (val & DF_1_STUB)
9886                     {
9887                       printf (" STUB");
9888                       val ^= DF_1_STUB;
9889                     }
9890                   if (val & DF_1_PIE)
9891                     {
9892                       printf (" PIE");
9893                       val ^= DF_1_PIE;
9894                     }
9895                   if (val != 0)
9896                     printf (" %lx", val);
9897                   puts ("");
9898                 }
9899             }
9900           break;
9901
9902         case DT_PLTREL:
9903           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9904           if (do_dynamic)
9905             puts (get_dynamic_type (entry->d_un.d_val));
9906           break;
9907
9908         case DT_NULL    :
9909         case DT_NEEDED  :
9910         case DT_PLTGOT  :
9911         case DT_HASH    :
9912         case DT_STRTAB  :
9913         case DT_SYMTAB  :
9914         case DT_RELA    :
9915         case DT_INIT    :
9916         case DT_FINI    :
9917         case DT_SONAME  :
9918         case DT_RPATH   :
9919         case DT_SYMBOLIC:
9920         case DT_REL     :
9921         case DT_DEBUG   :
9922         case DT_TEXTREL :
9923         case DT_JMPREL  :
9924         case DT_RUNPATH :
9925           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9926
9927           if (do_dynamic)
9928             {
9929               char * name;
9930
9931               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9932                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9933               else
9934                 name = NULL;
9935
9936               if (name)
9937                 {
9938                   switch (entry->d_tag)
9939                     {
9940                     case DT_NEEDED:
9941                       printf (_("Shared library: [%s]"), name);
9942
9943                       if (streq (name, program_interpreter))
9944                         printf (_(" program interpreter"));
9945                       break;
9946
9947                     case DT_SONAME:
9948                       printf (_("Library soname: [%s]"), name);
9949                       break;
9950
9951                     case DT_RPATH:
9952                       printf (_("Library rpath: [%s]"), name);
9953                       break;
9954
9955                     case DT_RUNPATH:
9956                       printf (_("Library runpath: [%s]"), name);
9957                       break;
9958
9959                     default:
9960                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9961                       break;
9962                     }
9963                 }
9964               else
9965                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9966
9967               putchar ('\n');
9968             }
9969           break;
9970
9971         case DT_PLTRELSZ:
9972         case DT_RELASZ  :
9973         case DT_STRSZ   :
9974         case DT_RELSZ   :
9975         case DT_RELAENT :
9976         case DT_SYMENT  :
9977         case DT_RELENT  :
9978           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9979           /* Fall through.  */
9980         case DT_PLTPADSZ:
9981         case DT_MOVEENT :
9982         case DT_MOVESZ  :
9983         case DT_INIT_ARRAYSZ:
9984         case DT_FINI_ARRAYSZ:
9985         case DT_GNU_CONFLICTSZ:
9986         case DT_GNU_LIBLISTSZ:
9987           if (do_dynamic)
9988             {
9989               print_vma (entry->d_un.d_val, UNSIGNED);
9990               printf (_(" (bytes)\n"));
9991             }
9992           break;
9993
9994         case DT_VERDEFNUM:
9995         case DT_VERNEEDNUM:
9996         case DT_RELACOUNT:
9997         case DT_RELCOUNT:
9998           if (do_dynamic)
9999             {
10000               print_vma (entry->d_un.d_val, UNSIGNED);
10001               putchar ('\n');
10002             }
10003           break;
10004
10005         case DT_SYMINSZ:
10006         case DT_SYMINENT:
10007         case DT_SYMINFO:
10008         case DT_USED:
10009         case DT_INIT_ARRAY:
10010         case DT_FINI_ARRAY:
10011           if (do_dynamic)
10012             {
10013               if (entry->d_tag == DT_USED
10014                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10015                 {
10016                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10017
10018                   if (*name)
10019                     {
10020                       printf (_("Not needed object: [%s]\n"), name);
10021                       break;
10022                     }
10023                 }
10024
10025               print_vma (entry->d_un.d_val, PREFIX_HEX);
10026               putchar ('\n');
10027             }
10028           break;
10029
10030         case DT_BIND_NOW:
10031           /* The value of this entry is ignored.  */
10032           if (do_dynamic)
10033             putchar ('\n');
10034           break;
10035
10036         case DT_GNU_PRELINKED:
10037           if (do_dynamic)
10038             {
10039               struct tm * tmp;
10040               time_t atime = entry->d_un.d_val;
10041
10042               tmp = gmtime (&atime);
10043               /* PR 17533 file: 041-1244816-0.004.  */
10044               if (tmp == NULL)
10045                 printf (_("<corrupt time val: %lx"),
10046                         (unsigned long) atime);
10047               else
10048                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10049                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10050                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10051
10052             }
10053           break;
10054
10055         case DT_GNU_HASH:
10056           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10057           if (do_dynamic)
10058             {
10059               print_vma (entry->d_un.d_val, PREFIX_HEX);
10060               putchar ('\n');
10061             }
10062           break;
10063
10064         default:
10065           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10066             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10067               entry->d_un.d_val;
10068
10069           if (do_dynamic)
10070             {
10071               switch (elf_header.e_machine)
10072                 {
10073                 case EM_MIPS:
10074                 case EM_MIPS_RS3_LE:
10075                   dynamic_section_mips_val (entry);
10076                   break;
10077                 case EM_PARISC:
10078                   dynamic_section_parisc_val (entry);
10079                   break;
10080                 case EM_IA_64:
10081                   dynamic_section_ia64_val (entry);
10082                   break;
10083                 default:
10084                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10085                   putchar ('\n');
10086                 }
10087             }
10088           break;
10089         }
10090     }
10091
10092   return TRUE;
10093 }
10094
10095 static char *
10096 get_ver_flags (unsigned int flags)
10097 {
10098   static char buff[32];
10099
10100   buff[0] = 0;
10101
10102   if (flags == 0)
10103     return _("none");
10104
10105   if (flags & VER_FLG_BASE)
10106     strcat (buff, "BASE");
10107
10108   if (flags & VER_FLG_WEAK)
10109     {
10110       if (flags & VER_FLG_BASE)
10111         strcat (buff, " | ");
10112
10113       strcat (buff, "WEAK");
10114     }
10115
10116   if (flags & VER_FLG_INFO)
10117     {
10118       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10119         strcat (buff, " | ");
10120
10121       strcat (buff, "INFO");
10122     }
10123
10124   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10125     {
10126       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10127         strcat (buff, " | ");
10128
10129       strcat (buff, _("<unknown>"));
10130     }
10131
10132   return buff;
10133 }
10134
10135 /* Display the contents of the version sections.  */
10136
10137 static bfd_boolean
10138 process_version_sections (FILE * file)
10139 {
10140   Elf_Internal_Shdr * section;
10141   unsigned i;
10142   bfd_boolean found = FALSE;
10143
10144   if (! do_version)
10145     return TRUE;
10146
10147   for (i = 0, section = section_headers;
10148        i < elf_header.e_shnum;
10149        i++, section++)
10150     {
10151       switch (section->sh_type)
10152         {
10153         case SHT_GNU_verdef:
10154           {
10155             Elf_External_Verdef * edefs;
10156             unsigned int idx;
10157             unsigned int cnt;
10158             unsigned int end;
10159             char * endbuf;
10160
10161             found = TRUE;
10162
10163             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10164                     printable_section_name (section),
10165                     section->sh_info);
10166
10167             printf (_("  Addr: 0x"));
10168             printf_vma (section->sh_addr);
10169             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10170                     (unsigned long) section->sh_offset, section->sh_link,
10171                     printable_section_name_from_index (section->sh_link));
10172
10173             edefs = (Elf_External_Verdef *)
10174                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10175                           _("version definition section"));
10176             if (!edefs)
10177               break;
10178             endbuf = (char *) edefs + section->sh_size;
10179
10180             /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
10181             end = (section->sh_info < section->sh_size
10182                    ? section->sh_info : section->sh_size);
10183             for (idx = cnt = 0; cnt < end; ++cnt)
10184               {
10185                 char * vstart;
10186                 Elf_External_Verdef * edef;
10187                 Elf_Internal_Verdef ent;
10188                 Elf_External_Verdaux * eaux;
10189                 Elf_Internal_Verdaux aux;
10190                 unsigned int isum;
10191                 int j;
10192
10193                 /* Check for very large indices.  */
10194                 if (idx > (size_t) (endbuf - (char *) edefs))
10195                   break;
10196
10197                 vstart = ((char *) edefs) + idx;
10198                 if (vstart + sizeof (*edef) > endbuf)
10199                   break;
10200
10201                 edef = (Elf_External_Verdef *) vstart;
10202
10203                 ent.vd_version = BYTE_GET (edef->vd_version);
10204                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10205                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10206                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10207                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10208                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10209                 ent.vd_next    = BYTE_GET (edef->vd_next);
10210
10211                 printf (_("  %#06x: Rev: %d  Flags: %s"),
10212                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10213
10214                 printf (_("  Index: %d  Cnt: %d  "),
10215                         ent.vd_ndx, ent.vd_cnt);
10216
10217                 /* Check for overflow and underflow.  */
10218                 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart)
10219                     || (vstart + ent.vd_aux < vstart))
10220                   break;
10221
10222                 vstart += ent.vd_aux;
10223
10224                 eaux = (Elf_External_Verdaux *) vstart;
10225
10226                 aux.vda_name = BYTE_GET (eaux->vda_name);
10227                 aux.vda_next = BYTE_GET (eaux->vda_next);
10228
10229                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10230                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10231                 else
10232                   printf (_("Name index: %ld\n"), aux.vda_name);
10233
10234                 isum = idx + ent.vd_aux;
10235
10236                 for (j = 1; j < ent.vd_cnt; j++)
10237                   {
10238                     /* Check for overflow.  */
10239                     if (aux.vda_next > (size_t) (endbuf - vstart))
10240                       break;
10241
10242                     isum   += aux.vda_next;
10243                     vstart += aux.vda_next;
10244
10245                     eaux = (Elf_External_Verdaux *) vstart;
10246                     if (vstart + sizeof (*eaux) > endbuf)
10247                       break;
10248
10249                     aux.vda_name = BYTE_GET (eaux->vda_name);
10250                     aux.vda_next = BYTE_GET (eaux->vda_next);
10251
10252                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10253                       printf (_("  %#06x: Parent %d: %s\n"),
10254                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10255                     else
10256                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
10257                               isum, j, aux.vda_name);
10258                   }
10259
10260                 if (j < ent.vd_cnt)
10261                   printf (_("  Version def aux past end of section\n"));
10262
10263                 /* PR 17531:
10264                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10265                 if (idx + ent.vd_next < idx)
10266                   break;
10267
10268                 idx += ent.vd_next;
10269               }
10270
10271             if (cnt < section->sh_info)
10272               printf (_("  Version definition past end of section\n"));
10273
10274             free (edefs);
10275           }
10276           break;
10277
10278         case SHT_GNU_verneed:
10279           {
10280             Elf_External_Verneed * eneed;
10281             unsigned int idx;
10282             unsigned int cnt;
10283             char * endbuf;
10284
10285             found = TRUE;
10286
10287             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10288                     printable_section_name (section), section->sh_info);
10289
10290             printf (_(" Addr: 0x"));
10291             printf_vma (section->sh_addr);
10292             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10293                     (unsigned long) section->sh_offset, section->sh_link,
10294                     printable_section_name_from_index (section->sh_link));
10295
10296             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10297                                                        section->sh_offset, 1,
10298                                                        section->sh_size,
10299                                                        _("Version Needs section"));
10300             if (!eneed)
10301               break;
10302             endbuf = (char *) eneed + section->sh_size;
10303
10304             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10305               {
10306                 Elf_External_Verneed * entry;
10307                 Elf_Internal_Verneed ent;
10308                 unsigned int isum;
10309                 int j;
10310                 char * vstart;
10311
10312                 if (idx > (size_t) (endbuf - (char *) eneed))
10313                   break;
10314
10315                 vstart = ((char *) eneed) + idx;
10316                 if (vstart + sizeof (*entry) > endbuf)
10317                   break;
10318
10319                 entry = (Elf_External_Verneed *) vstart;
10320
10321                 ent.vn_version = BYTE_GET (entry->vn_version);
10322                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10323                 ent.vn_file    = BYTE_GET (entry->vn_file);
10324                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10325                 ent.vn_next    = BYTE_GET (entry->vn_next);
10326
10327                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
10328
10329                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10330                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10331                 else
10332                   printf (_("  File: %lx"), ent.vn_file);
10333
10334                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10335
10336                 /* Check for overflow.  */
10337                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10338                   break;
10339                 vstart += ent.vn_aux;
10340
10341                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10342                   {
10343                     Elf_External_Vernaux * eaux;
10344                     Elf_Internal_Vernaux aux;
10345
10346                     if (vstart + sizeof (*eaux) > endbuf)
10347                       break;
10348                     eaux = (Elf_External_Vernaux *) vstart;
10349
10350                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10351                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10352                     aux.vna_other = BYTE_GET (eaux->vna_other);
10353                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10354                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10355
10356                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10357                       printf (_("  %#06x:   Name: %s"),
10358                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10359                     else
10360                       printf (_("  %#06x:   Name index: %lx"),
10361                               isum, aux.vna_name);
10362
10363                     printf (_("  Flags: %s  Version: %d\n"),
10364                             get_ver_flags (aux.vna_flags), aux.vna_other);
10365
10366                     /* Check for overflow.  */
10367                     if (aux.vna_next > (size_t) (endbuf - vstart)
10368                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10369                       {
10370                         warn (_("Invalid vna_next field of %lx\n"),
10371                               aux.vna_next);
10372                         j = ent.vn_cnt;
10373                         break;
10374                       }
10375                     isum   += aux.vna_next;
10376                     vstart += aux.vna_next;
10377                   }
10378
10379                 if (j < ent.vn_cnt)
10380                   warn (_("Missing Version Needs auxillary information\n"));
10381
10382                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
10383                   {
10384                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10385                     cnt = section->sh_info;
10386                     break;
10387                   }
10388                 idx += ent.vn_next;
10389               }
10390
10391             if (cnt < section->sh_info)
10392               warn (_("Missing Version Needs information\n"));
10393
10394             free (eneed);
10395           }
10396           break;
10397
10398         case SHT_GNU_versym:
10399           {
10400             Elf_Internal_Shdr * link_section;
10401             size_t total;
10402             unsigned int cnt;
10403             unsigned char * edata;
10404             unsigned short * data;
10405             char * strtab;
10406             Elf_Internal_Sym * symbols;
10407             Elf_Internal_Shdr * string_sec;
10408             unsigned long num_syms;
10409             long off;
10410
10411             if (section->sh_link >= elf_header.e_shnum)
10412               break;
10413
10414             link_section = section_headers + section->sh_link;
10415             total = section->sh_size / sizeof (Elf_External_Versym);
10416
10417             if (link_section->sh_link >= elf_header.e_shnum)
10418               break;
10419
10420             found = TRUE;
10421
10422             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10423             if (symbols == NULL)
10424               break;
10425
10426             string_sec = section_headers + link_section->sh_link;
10427
10428             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10429                                         string_sec->sh_size,
10430                                         _("version string table"));
10431             if (!strtab)
10432               {
10433                 free (symbols);
10434                 break;
10435               }
10436
10437             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10438                     printable_section_name (section), (unsigned long) total);
10439
10440             printf (_(" Addr: "));
10441             printf_vma (section->sh_addr);
10442             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10443                     (unsigned long) section->sh_offset, section->sh_link,
10444                     printable_section_name (link_section));
10445
10446             off = offset_from_vma (file,
10447                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10448                                    total * sizeof (short));
10449             edata = (unsigned char *) get_data (NULL, file, off, total,
10450                                                 sizeof (short),
10451                                                 _("version symbol data"));
10452             if (!edata)
10453               {
10454                 free (strtab);
10455                 free (symbols);
10456                 break;
10457               }
10458
10459             data = (short unsigned int *) cmalloc (total, sizeof (short));
10460
10461             for (cnt = total; cnt --;)
10462               data[cnt] = byte_get (edata + cnt * sizeof (short),
10463                                     sizeof (short));
10464
10465             free (edata);
10466
10467             for (cnt = 0; cnt < total; cnt += 4)
10468               {
10469                 int j, nn;
10470                 char *name;
10471                 char *invalid = _("*invalid*");
10472
10473                 printf ("  %03x:", cnt);
10474
10475                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10476                   switch (data[cnt + j])
10477                     {
10478                     case 0:
10479                       fputs (_("   0 (*local*)    "), stdout);
10480                       break;
10481
10482                     case 1:
10483                       fputs (_("   1 (*global*)   "), stdout);
10484                       break;
10485
10486                     default:
10487                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10488                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10489
10490                       /* If this index value is greater than the size of the symbols
10491                          array, break to avoid an out-of-bounds read.  */
10492                       if ((unsigned long)(cnt + j) >= num_syms)
10493                         {
10494                           warn (_("invalid index into symbol array\n"));
10495                           break;
10496                         }
10497
10498                       name = NULL;
10499                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10500                         {
10501                           Elf_Internal_Verneed ivn;
10502                           unsigned long offset;
10503
10504                           offset = offset_from_vma
10505                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10506                              sizeof (Elf_External_Verneed));
10507
10508                           do
10509                             {
10510                               Elf_Internal_Vernaux ivna;
10511                               Elf_External_Verneed evn;
10512                               Elf_External_Vernaux evna;
10513                               unsigned long a_off;
10514
10515                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10516                                             _("version need")) == NULL)
10517                                 break;
10518
10519                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10520                               ivn.vn_next = BYTE_GET (evn.vn_next);
10521
10522                               a_off = offset + ivn.vn_aux;
10523
10524                               do
10525                                 {
10526                                   if (get_data (&evna, file, a_off, sizeof (evna),
10527                                                 1, _("version need aux (2)")) == NULL)
10528                                     {
10529                                       ivna.vna_next  = 0;
10530                                       ivna.vna_other = 0;
10531                                     }
10532                                   else
10533                                     {
10534                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10535                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10536                                     }
10537
10538                                   a_off += ivna.vna_next;
10539                                 }
10540                               while (ivna.vna_other != data[cnt + j]
10541                                      && ivna.vna_next != 0);
10542
10543                               if (ivna.vna_other == data[cnt + j])
10544                                 {
10545                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10546
10547                                   if (ivna.vna_name >= string_sec->sh_size)
10548                                     name = invalid;
10549                                   else
10550                                     name = strtab + ivna.vna_name;
10551                                   break;
10552                                 }
10553
10554                               offset += ivn.vn_next;
10555                             }
10556                           while (ivn.vn_next);
10557                         }
10558
10559                       if (data[cnt + j] != 0x8001
10560                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10561                         {
10562                           Elf_Internal_Verdef ivd;
10563                           Elf_External_Verdef evd;
10564                           unsigned long offset;
10565
10566                           offset = offset_from_vma
10567                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10568                              sizeof evd);
10569
10570                           do
10571                             {
10572                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10573                                             _("version def")) == NULL)
10574                                 {
10575                                   ivd.vd_next = 0;
10576                                   /* PR 17531: file: 046-1082287-0.004.  */
10577                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10578                                   break;
10579                                 }
10580                               else
10581                                 {
10582                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10583                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10584                                 }
10585
10586                               offset += ivd.vd_next;
10587                             }
10588                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10589                                  && ivd.vd_next != 0);
10590
10591                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10592                             {
10593                               Elf_External_Verdaux evda;
10594                               Elf_Internal_Verdaux ivda;
10595
10596                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10597
10598                               if (get_data (&evda, file,
10599                                             offset - ivd.vd_next + ivd.vd_aux,
10600                                             sizeof (evda), 1,
10601                                             _("version def aux")) == NULL)
10602                                 break;
10603
10604                               ivda.vda_name = BYTE_GET (evda.vda_name);
10605
10606                               if (ivda.vda_name >= string_sec->sh_size)
10607                                 name = invalid;
10608                               else if (name != NULL && name != invalid)
10609                                 name = _("*both*");
10610                               else
10611                                 name = strtab + ivda.vda_name;
10612                             }
10613                         }
10614                       if (name != NULL)
10615                         nn += printf ("(%s%-*s",
10616                                       name,
10617                                       12 - (int) strlen (name),
10618                                       ")");
10619
10620                       if (nn < 18)
10621                         printf ("%*c", 18 - nn, ' ');
10622                     }
10623
10624                 putchar ('\n');
10625               }
10626
10627             free (data);
10628             free (strtab);
10629             free (symbols);
10630           }
10631           break;
10632
10633         default:
10634           break;
10635         }
10636     }
10637
10638   if (! found)
10639     printf (_("\nNo version information found in this file.\n"));
10640
10641   return TRUE;
10642 }
10643
10644 static const char *
10645 get_symbol_binding (unsigned int binding)
10646 {
10647   static char buff[32];
10648
10649   switch (binding)
10650     {
10651     case STB_LOCAL:     return "LOCAL";
10652     case STB_GLOBAL:    return "GLOBAL";
10653     case STB_WEAK:      return "WEAK";
10654     default:
10655       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10656         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10657                   binding);
10658       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10659         {
10660           if (binding == STB_GNU_UNIQUE
10661               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10662                   /* GNU is still using the default value 0.  */
10663                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10664             return "UNIQUE";
10665           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10666         }
10667       else
10668         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10669       return buff;
10670     }
10671 }
10672
10673 static const char *
10674 get_symbol_type (unsigned int type)
10675 {
10676   static char buff[32];
10677
10678   switch (type)
10679     {
10680     case STT_NOTYPE:    return "NOTYPE";
10681     case STT_OBJECT:    return "OBJECT";
10682     case STT_FUNC:      return "FUNC";
10683     case STT_SECTION:   return "SECTION";
10684     case STT_FILE:      return "FILE";
10685     case STT_COMMON:    return "COMMON";
10686     case STT_TLS:       return "TLS";
10687     case STT_RELC:      return "RELC";
10688     case STT_SRELC:     return "SRELC";
10689     default:
10690       if (type >= STT_LOPROC && type <= STT_HIPROC)
10691         {
10692           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10693             return "THUMB_FUNC";
10694
10695           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10696             return "REGISTER";
10697
10698           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10699             return "PARISC_MILLI";
10700
10701           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10702         }
10703       else if (type >= STT_LOOS && type <= STT_HIOS)
10704         {
10705           if (elf_header.e_machine == EM_PARISC)
10706             {
10707               if (type == STT_HP_OPAQUE)
10708                 return "HP_OPAQUE";
10709               if (type == STT_HP_STUB)
10710                 return "HP_STUB";
10711             }
10712
10713           if (type == STT_GNU_IFUNC
10714               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10715                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10716                   /* GNU is still using the default value 0.  */
10717                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10718             return "IFUNC";
10719
10720           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10721         }
10722       else
10723         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10724       return buff;
10725     }
10726 }
10727
10728 static const char *
10729 get_symbol_visibility (unsigned int visibility)
10730 {
10731   switch (visibility)
10732     {
10733     case STV_DEFAULT:   return "DEFAULT";
10734     case STV_INTERNAL:  return "INTERNAL";
10735     case STV_HIDDEN:    return "HIDDEN";
10736     case STV_PROTECTED: return "PROTECTED";
10737     default:
10738       error (_("Unrecognized visibility value: %u"), visibility);
10739       return _("<unknown>");
10740     }
10741 }
10742
10743 static const char *
10744 get_solaris_symbol_visibility (unsigned int visibility)
10745 {
10746   switch (visibility)
10747     {
10748     case 4: return "EXPORTED";
10749     case 5: return "SINGLETON";
10750     case 6: return "ELIMINATE";
10751     default: return get_symbol_visibility (visibility);
10752     }
10753 }
10754
10755 static const char *
10756 get_mips_symbol_other (unsigned int other)
10757 {
10758   switch (other)
10759     {
10760     case STO_OPTIONAL:      return "OPTIONAL";
10761     case STO_MIPS_PLT:      return "MIPS PLT";
10762     case STO_MIPS_PIC:      return "MIPS PIC";
10763     case STO_MICROMIPS:     return "MICROMIPS";
10764     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10765     case STO_MIPS16:        return "MIPS16";
10766     default:                return NULL;
10767     }
10768 }
10769
10770 static const char *
10771 get_ia64_symbol_other (unsigned int other)
10772 {
10773   if (is_ia64_vms ())
10774     {
10775       static char res[32];
10776
10777       res[0] = 0;
10778
10779       /* Function types is for images and .STB files only.  */
10780       switch (elf_header.e_type)
10781         {
10782         case ET_DYN:
10783         case ET_EXEC:
10784           switch (VMS_ST_FUNC_TYPE (other))
10785             {
10786             case VMS_SFT_CODE_ADDR:
10787               strcat (res, " CA");
10788               break;
10789             case VMS_SFT_SYMV_IDX:
10790               strcat (res, " VEC");
10791               break;
10792             case VMS_SFT_FD:
10793               strcat (res, " FD");
10794               break;
10795             case VMS_SFT_RESERVE:
10796               strcat (res, " RSV");
10797               break;
10798             default:
10799               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10800                     VMS_ST_FUNC_TYPE (other));
10801               strcat (res, " <unknown>");
10802               break;
10803             }
10804           break;
10805         default:
10806           break;
10807         }
10808       switch (VMS_ST_LINKAGE (other))
10809         {
10810         case VMS_STL_IGNORE:
10811           strcat (res, " IGN");
10812           break;
10813         case VMS_STL_RESERVE:
10814           strcat (res, " RSV");
10815           break;
10816         case VMS_STL_STD:
10817           strcat (res, " STD");
10818           break;
10819         case VMS_STL_LNK:
10820           strcat (res, " LNK");
10821           break;
10822         default:
10823           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10824                 VMS_ST_LINKAGE (other));
10825           strcat (res, " <unknown>");
10826           break;
10827         }
10828
10829       if (res[0] != 0)
10830         return res + 1;
10831       else
10832         return res;
10833     }
10834   return NULL;
10835 }
10836
10837 static const char *
10838 get_ppc64_symbol_other (unsigned int other)
10839 {
10840   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10841     {
10842       static char buf[32];
10843       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10844                 PPC64_LOCAL_ENTRY_OFFSET (other));
10845       return buf;
10846     }
10847   return NULL;
10848 }
10849
10850 static const char *
10851 get_symbol_other (unsigned int other)
10852 {
10853   const char * result = NULL;
10854   static char buff [32];
10855
10856   if (other == 0)
10857     return "";
10858
10859   switch (elf_header.e_machine)
10860     {
10861     case EM_MIPS:
10862       result = get_mips_symbol_other (other);
10863       break;
10864     case EM_IA_64:
10865       result = get_ia64_symbol_other (other);
10866       break;
10867     case EM_PPC64:
10868       result = get_ppc64_symbol_other (other);
10869       break;
10870     default:
10871       result = NULL;
10872       break;
10873     }
10874
10875   if (result)
10876     return result;
10877
10878   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10879   return buff;
10880 }
10881
10882 static const char *
10883 get_symbol_index_type (unsigned int type)
10884 {
10885   static char buff[32];
10886
10887   switch (type)
10888     {
10889     case SHN_UNDEF:     return "UND";
10890     case SHN_ABS:       return "ABS";
10891     case SHN_COMMON:    return "COM";
10892     default:
10893       if (type == SHN_IA_64_ANSI_COMMON
10894           && elf_header.e_machine == EM_IA_64
10895           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10896         return "ANSI_COM";
10897       else if ((elf_header.e_machine == EM_X86_64
10898                 || elf_header.e_machine == EM_L1OM
10899                 || elf_header.e_machine == EM_K1OM)
10900                && type == SHN_X86_64_LCOMMON)
10901         return "LARGE_COM";
10902       else if ((type == SHN_MIPS_SCOMMON
10903                 && elf_header.e_machine == EM_MIPS)
10904                || (type == SHN_TIC6X_SCOMMON
10905                    && elf_header.e_machine == EM_TI_C6000))
10906         return "SCOM";
10907       else if (type == SHN_MIPS_SUNDEFINED
10908                && elf_header.e_machine == EM_MIPS)
10909         return "SUND";
10910       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10911         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10912       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10913         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10914       else if (type >= SHN_LORESERVE)
10915         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10916       else if (type >= elf_header.e_shnum)
10917         sprintf (buff, _("bad section index[%3d]"), type);
10918       else
10919         sprintf (buff, "%3d", type);
10920       break;
10921     }
10922
10923   return buff;
10924 }
10925
10926 static bfd_vma *
10927 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10928 {
10929   unsigned char * e_data;
10930   bfd_vma * i_data;
10931
10932   /* If the size_t type is smaller than the bfd_size_type, eg because
10933      you are building a 32-bit tool on a 64-bit host, then make sure
10934      that when (number) is cast to (size_t) no information is lost.  */
10935   if (sizeof (size_t) < sizeof (bfd_size_type)
10936       && (bfd_size_type) ((size_t) number) != number)
10937     {
10938       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10939                " elements of size %u\n"),
10940              number, ent_size);
10941       return NULL;
10942     }
10943
10944   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10945      attempting to allocate memory when the read is bound to fail.  */
10946   if (ent_size * number > current_file_size)
10947     {
10948       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10949              number);
10950       return NULL;
10951     }
10952
10953   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10954   if (e_data == NULL)
10955     {
10956       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10957              number);
10958       return NULL;
10959     }
10960
10961   if (fread (e_data, ent_size, (size_t) number, file) != number)
10962     {
10963       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10964              number * ent_size);
10965       free (e_data);
10966       return NULL;
10967     }
10968
10969   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10970   if (i_data == NULL)
10971     {
10972       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10973                " dynamic entries\n"),
10974              number);
10975       free (e_data);
10976       return NULL;
10977     }
10978
10979   while (number--)
10980     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10981
10982   free (e_data);
10983
10984   return i_data;
10985 }
10986
10987 static void
10988 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10989 {
10990   Elf_Internal_Sym * psym;
10991   int n;
10992
10993   n = print_vma (si, DEC_5);
10994   if (n < 5)
10995     fputs (&"     "[n], stdout);
10996   printf (" %3lu: ", hn);
10997
10998   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10999     {
11000       printf (_("<No info available for dynamic symbol number %lu>\n"),
11001               (unsigned long) si);
11002       return;
11003     }
11004
11005   psym = dynamic_symbols + si;
11006   print_vma (psym->st_value, LONG_HEX);
11007   putchar (' ');
11008   print_vma (psym->st_size, DEC_5);
11009
11010   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11011   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11012
11013   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11014     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11015   else
11016     {
11017       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11018
11019       printf (" %-7s",  get_symbol_visibility (vis));
11020       /* Check to see if any other bits in the st_other field are set.
11021          Note - displaying this information disrupts the layout of the
11022          table being generated, but for the moment this case is very
11023          rare.  */
11024       if (psym->st_other ^ vis)
11025         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11026     }
11027
11028   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11029   if (VALID_DYNAMIC_NAME (psym->st_name))
11030     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11031   else
11032     printf (_(" <corrupt: %14ld>"), psym->st_name);
11033   putchar ('\n');
11034 }
11035
11036 static const char *
11037 get_symbol_version_string (FILE *                       file,
11038                            bfd_boolean                  is_dynsym,
11039                            const char *                 strtab,
11040                            unsigned long int            strtab_size,
11041                            unsigned int                 si,
11042                            Elf_Internal_Sym *           psym,
11043                            enum versioned_symbol_info * sym_info,
11044                            unsigned short *             vna_other)
11045 {
11046   unsigned char data[2];
11047   unsigned short vers_data;
11048   unsigned long offset;
11049
11050   if (!is_dynsym
11051       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11052     return NULL;
11053
11054   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11055                             sizeof data + si * sizeof (vers_data));
11056
11057   if (get_data (&data, file, offset + si * sizeof (vers_data),
11058                 sizeof (data), 1, _("version data")) == NULL)
11059     return NULL;
11060
11061   vers_data = byte_get (data, 2);
11062
11063   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11064     return NULL;
11065
11066   /* Usually we'd only see verdef for defined symbols, and verneed for
11067      undefined symbols.  However, symbols defined by the linker in
11068      .dynbss for variables copied from a shared library in order to
11069      avoid text relocations are defined yet have verneed.  We could
11070      use a heuristic to detect the special case, for example, check
11071      for verneed first on symbols defined in SHT_NOBITS sections, but
11072      it is simpler and more reliable to just look for both verdef and
11073      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11074
11075   if (psym->st_shndx != SHN_UNDEF
11076       && vers_data != 0x8001
11077       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11078     {
11079       Elf_Internal_Verdef ivd;
11080       Elf_Internal_Verdaux ivda;
11081       Elf_External_Verdaux evda;
11082       unsigned long off;
11083
11084       off = offset_from_vma (file,
11085                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11086                              sizeof (Elf_External_Verdef));
11087
11088       do
11089         {
11090           Elf_External_Verdef evd;
11091
11092           if (get_data (&evd, file, off, sizeof (evd), 1,
11093                         _("version def")) == NULL)
11094             {
11095               ivd.vd_ndx = 0;
11096               ivd.vd_aux = 0;
11097               ivd.vd_next = 0;
11098             }
11099           else
11100             {
11101               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11102               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11103               ivd.vd_next = BYTE_GET (evd.vd_next);
11104             }
11105
11106           off += ivd.vd_next;
11107         }
11108       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11109
11110       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11111         {
11112           off -= ivd.vd_next;
11113           off += ivd.vd_aux;
11114
11115           if (get_data (&evda, file, off, sizeof (evda), 1,
11116                         _("version def aux")) != NULL)
11117             {
11118               ivda.vda_name = BYTE_GET (evda.vda_name);
11119
11120               if (psym->st_name != ivda.vda_name)
11121                 {
11122                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11123                                ? symbol_hidden : symbol_public);
11124                   return (ivda.vda_name < strtab_size
11125                           ? strtab + ivda.vda_name : _("<corrupt>"));
11126                 }
11127             }
11128         }
11129     }
11130
11131   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11132     {
11133       Elf_External_Verneed evn;
11134       Elf_Internal_Verneed ivn;
11135       Elf_Internal_Vernaux ivna;
11136
11137       offset = offset_from_vma (file,
11138                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11139                                 sizeof evn);
11140       do
11141         {
11142           unsigned long vna_off;
11143
11144           if (get_data (&evn, file, offset, sizeof (evn), 1,
11145                         _("version need")) == NULL)
11146             {
11147               ivna.vna_next = 0;
11148               ivna.vna_other = 0;
11149               ivna.vna_name = 0;
11150               break;
11151             }
11152
11153           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11154           ivn.vn_next = BYTE_GET (evn.vn_next);
11155
11156           vna_off = offset + ivn.vn_aux;
11157
11158           do
11159             {
11160               Elf_External_Vernaux evna;
11161
11162               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11163                             _("version need aux (3)")) == NULL)
11164                 {
11165                   ivna.vna_next = 0;
11166                   ivna.vna_other = 0;
11167                   ivna.vna_name = 0;
11168                 }
11169               else
11170                 {
11171                   ivna.vna_other = BYTE_GET (evna.vna_other);
11172                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11173                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11174                 }
11175
11176               vna_off += ivna.vna_next;
11177             }
11178           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11179
11180           if (ivna.vna_other == vers_data)
11181             break;
11182
11183           offset += ivn.vn_next;
11184         }
11185       while (ivn.vn_next != 0);
11186
11187       if (ivna.vna_other == vers_data)
11188         {
11189           *sym_info = symbol_undefined;
11190           *vna_other = ivna.vna_other;
11191           return (ivna.vna_name < strtab_size
11192                   ? strtab + ivna.vna_name : _("<corrupt>"));
11193         }
11194     }
11195   return NULL;
11196 }
11197
11198 /* Dump the symbol table.  */
11199 static bfd_boolean
11200 process_symbol_table (FILE * file)
11201 {
11202   Elf_Internal_Shdr * section;
11203   bfd_size_type nbuckets = 0;
11204   bfd_size_type nchains = 0;
11205   bfd_vma * buckets = NULL;
11206   bfd_vma * chains = NULL;
11207   bfd_vma ngnubuckets = 0;
11208   bfd_vma * gnubuckets = NULL;
11209   bfd_vma * gnuchains = NULL;
11210   bfd_vma gnusymidx = 0;
11211   bfd_size_type ngnuchains = 0;
11212
11213   if (!do_syms && !do_dyn_syms && !do_histogram)
11214     return TRUE;
11215
11216   if (dynamic_info[DT_HASH]
11217       && (do_histogram
11218           || (do_using_dynamic
11219               && !do_dyn_syms
11220               && dynamic_strings != NULL)))
11221     {
11222       unsigned char nb[8];
11223       unsigned char nc[8];
11224       unsigned int hash_ent_size = 4;
11225
11226       if ((elf_header.e_machine == EM_ALPHA
11227            || elf_header.e_machine == EM_S390
11228            || elf_header.e_machine == EM_S390_OLD)
11229           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11230         hash_ent_size = 8;
11231
11232       if (fseek (file,
11233                  (archive_file_offset
11234                   + offset_from_vma (file, dynamic_info[DT_HASH],
11235                                      sizeof nb + sizeof nc)),
11236                  SEEK_SET))
11237         {
11238           error (_("Unable to seek to start of dynamic information\n"));
11239           goto no_hash;
11240         }
11241
11242       if (fread (nb, hash_ent_size, 1, file) != 1)
11243         {
11244           error (_("Failed to read in number of buckets\n"));
11245           goto no_hash;
11246         }
11247
11248       if (fread (nc, hash_ent_size, 1, file) != 1)
11249         {
11250           error (_("Failed to read in number of chains\n"));
11251           goto no_hash;
11252         }
11253
11254       nbuckets = byte_get (nb, hash_ent_size);
11255       nchains  = byte_get (nc, hash_ent_size);
11256
11257       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11258       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11259
11260     no_hash:
11261       if (buckets == NULL || chains == NULL)
11262         {
11263           if (do_using_dynamic)
11264             return FALSE;
11265           free (buckets);
11266           free (chains);
11267           buckets = NULL;
11268           chains = NULL;
11269           nbuckets = 0;
11270           nchains = 0;
11271         }
11272     }
11273
11274   if (dynamic_info_DT_GNU_HASH
11275       && (do_histogram
11276           || (do_using_dynamic
11277               && !do_dyn_syms
11278               && dynamic_strings != NULL)))
11279     {
11280       unsigned char nb[16];
11281       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11282       bfd_vma buckets_vma;
11283
11284       if (fseek (file,
11285                  (archive_file_offset
11286                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11287                                      sizeof nb)),
11288                  SEEK_SET))
11289         {
11290           error (_("Unable to seek to start of dynamic information\n"));
11291           goto no_gnu_hash;
11292         }
11293
11294       if (fread (nb, 16, 1, file) != 1)
11295         {
11296           error (_("Failed to read in number of buckets\n"));
11297           goto no_gnu_hash;
11298         }
11299
11300       ngnubuckets = byte_get (nb, 4);
11301       gnusymidx = byte_get (nb + 4, 4);
11302       bitmaskwords = byte_get (nb + 8, 4);
11303       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11304       if (is_32bit_elf)
11305         buckets_vma += bitmaskwords * 4;
11306       else
11307         buckets_vma += bitmaskwords * 8;
11308
11309       if (fseek (file,
11310                  (archive_file_offset
11311                   + offset_from_vma (file, buckets_vma, 4)),
11312                  SEEK_SET))
11313         {
11314           error (_("Unable to seek to start of dynamic information\n"));
11315           goto no_gnu_hash;
11316         }
11317
11318       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11319
11320       if (gnubuckets == NULL)
11321         goto no_gnu_hash;
11322
11323       for (i = 0; i < ngnubuckets; i++)
11324         if (gnubuckets[i] != 0)
11325           {
11326             if (gnubuckets[i] < gnusymidx)
11327               return FALSE;
11328
11329             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11330               maxchain = gnubuckets[i];
11331           }
11332
11333       if (maxchain == 0xffffffff)
11334         goto no_gnu_hash;
11335
11336       maxchain -= gnusymidx;
11337
11338       if (fseek (file,
11339                  (archive_file_offset
11340                   + offset_from_vma (file, buckets_vma
11341                                            + 4 * (ngnubuckets + maxchain), 4)),
11342                  SEEK_SET))
11343         {
11344           error (_("Unable to seek to start of dynamic information\n"));
11345           goto no_gnu_hash;
11346         }
11347
11348       do
11349         {
11350           if (fread (nb, 4, 1, file) != 1)
11351             {
11352               error (_("Failed to determine last chain length\n"));
11353               goto no_gnu_hash;
11354             }
11355
11356           if (maxchain + 1 == 0)
11357             goto no_gnu_hash;
11358
11359           ++maxchain;
11360         }
11361       while ((byte_get (nb, 4) & 1) == 0);
11362
11363       if (fseek (file,
11364                  (archive_file_offset
11365                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11366                  SEEK_SET))
11367         {
11368           error (_("Unable to seek to start of dynamic information\n"));
11369           goto no_gnu_hash;
11370         }
11371
11372       gnuchains = get_dynamic_data (file, maxchain, 4);
11373       ngnuchains = maxchain;
11374
11375     no_gnu_hash:
11376       if (gnuchains == NULL)
11377         {
11378           free (gnubuckets);
11379           gnubuckets = NULL;
11380           ngnubuckets = 0;
11381           if (do_using_dynamic)
11382             return FALSE;
11383         }
11384     }
11385
11386   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11387       && do_syms
11388       && do_using_dynamic
11389       && dynamic_strings != NULL
11390       && dynamic_symbols != NULL)
11391     {
11392       unsigned long hn;
11393
11394       if (dynamic_info[DT_HASH])
11395         {
11396           bfd_vma si;
11397
11398           printf (_("\nSymbol table for image:\n"));
11399           if (is_32bit_elf)
11400             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11401           else
11402             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11403
11404           for (hn = 0; hn < nbuckets; hn++)
11405             {
11406               if (! buckets[hn])
11407                 continue;
11408
11409               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11410                 print_dynamic_symbol (si, hn);
11411             }
11412         }
11413
11414       if (dynamic_info_DT_GNU_HASH)
11415         {
11416           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11417           if (is_32bit_elf)
11418             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11419           else
11420             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11421
11422           for (hn = 0; hn < ngnubuckets; ++hn)
11423             if (gnubuckets[hn] != 0)
11424               {
11425                 bfd_vma si = gnubuckets[hn];
11426                 bfd_vma off = si - gnusymidx;
11427
11428                 do
11429                   {
11430                     print_dynamic_symbol (si, hn);
11431                     si++;
11432                   }
11433                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11434               }
11435         }
11436     }
11437   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11438            && section_headers != NULL)
11439     {
11440       unsigned int i;
11441
11442       for (i = 0, section = section_headers;
11443            i < elf_header.e_shnum;
11444            i++, section++)
11445         {
11446           unsigned int si;
11447           char * strtab = NULL;
11448           unsigned long int strtab_size = 0;
11449           Elf_Internal_Sym * symtab;
11450           Elf_Internal_Sym * psym;
11451           unsigned long num_syms;
11452
11453           if ((section->sh_type != SHT_SYMTAB
11454                && section->sh_type != SHT_DYNSYM)
11455               || (!do_syms
11456                   && section->sh_type == SHT_SYMTAB))
11457             continue;
11458
11459           if (section->sh_entsize == 0)
11460             {
11461               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11462                       printable_section_name (section));
11463               continue;
11464             }
11465
11466           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11467                   printable_section_name (section),
11468                   (unsigned long) (section->sh_size / section->sh_entsize));
11469
11470           if (is_32bit_elf)
11471             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11472           else
11473             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11474
11475           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11476           if (symtab == NULL)
11477             continue;
11478
11479           if (section->sh_link == elf_header.e_shstrndx)
11480             {
11481               strtab = string_table;
11482               strtab_size = string_table_length;
11483             }
11484           else if (section->sh_link < elf_header.e_shnum)
11485             {
11486               Elf_Internal_Shdr * string_sec;
11487
11488               string_sec = section_headers + section->sh_link;
11489
11490               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11491                                           1, string_sec->sh_size,
11492                                           _("string table"));
11493               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11494             }
11495
11496           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11497             {
11498               const char *version_string;
11499               enum versioned_symbol_info sym_info;
11500               unsigned short vna_other;
11501
11502               printf ("%6d: ", si);
11503               print_vma (psym->st_value, LONG_HEX);
11504               putchar (' ');
11505               print_vma (psym->st_size, DEC_5);
11506               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11507               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11508               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11509                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11510               else
11511                 {
11512                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11513
11514                   printf (" %-7s", get_symbol_visibility (vis));
11515                   /* Check to see if any other bits in the st_other field are set.
11516                      Note - displaying this information disrupts the layout of the
11517                      table being generated, but for the moment this case is very rare.  */
11518                   if (psym->st_other ^ vis)
11519                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11520                 }
11521               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11522               print_symbol (25, psym->st_name < strtab_size
11523                             ? strtab + psym->st_name : _("<corrupt>"));
11524
11525               version_string
11526                 = get_symbol_version_string (file,
11527                                              section->sh_type == SHT_DYNSYM,
11528                                              strtab, strtab_size, si,
11529                                              psym, &sym_info, &vna_other);
11530               if (version_string)
11531                 {
11532                   if (sym_info == symbol_undefined)
11533                     printf ("@%s (%d)", version_string, vna_other);
11534                   else
11535                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11536                             version_string);
11537                 }
11538
11539               putchar ('\n');
11540
11541               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11542                   && si >= section->sh_info
11543                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11544                   && elf_header.e_machine != EM_MIPS
11545                   /* Solaris binaries have been found to violate this requirement as
11546                      well.  Not sure if this is a bug or an ABI requirement.  */
11547                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11548                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11549                       si, printable_section_name (section), section->sh_info);
11550             }
11551
11552           free (symtab);
11553           if (strtab != string_table)
11554             free (strtab);
11555         }
11556     }
11557   else if (do_syms)
11558     printf
11559       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11560
11561   if (do_histogram && buckets != NULL)
11562     {
11563       unsigned long * lengths;
11564       unsigned long * counts;
11565       unsigned long hn;
11566       bfd_vma si;
11567       unsigned long maxlength = 0;
11568       unsigned long nzero_counts = 0;
11569       unsigned long nsyms = 0;
11570       unsigned long chained;
11571
11572       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11573               (unsigned long) nbuckets);
11574
11575       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11576       if (lengths == NULL)
11577         {
11578           error (_("Out of memory allocating space for histogram buckets\n"));
11579           return FALSE;
11580         }
11581
11582       printf (_(" Length  Number     %% of total  Coverage\n"));
11583       for (hn = 0; hn < nbuckets; ++hn)
11584         {
11585           for (si = buckets[hn], chained = 0;
11586                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11587                si = chains[si], ++chained)
11588             {
11589               ++nsyms;
11590               if (maxlength < ++lengths[hn])
11591                 ++maxlength;
11592             }
11593
11594             /* PR binutils/17531: A corrupt binary could contain broken
11595                histogram data.  Do not go into an infinite loop trying
11596                to process it.  */
11597             if (chained > nchains)
11598               {
11599                 error (_("histogram chain is corrupt\n"));
11600                 break;
11601               }
11602         }
11603
11604       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11605       if (counts == NULL)
11606         {
11607           free (lengths);
11608           error (_("Out of memory allocating space for histogram counts\n"));
11609           return FALSE;
11610         }
11611
11612       for (hn = 0; hn < nbuckets; ++hn)
11613         ++counts[lengths[hn]];
11614
11615       if (nbuckets > 0)
11616         {
11617           unsigned long i;
11618           printf ("      0  %-10lu (%5.1f%%)\n",
11619                   counts[0], (counts[0] * 100.0) / nbuckets);
11620           for (i = 1; i <= maxlength; ++i)
11621             {
11622               nzero_counts += counts[i] * i;
11623               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11624                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11625                       (nzero_counts * 100.0) / nsyms);
11626             }
11627         }
11628
11629       free (counts);
11630       free (lengths);
11631     }
11632
11633   if (buckets != NULL)
11634     {
11635       free (buckets);
11636       free (chains);
11637     }
11638
11639   if (do_histogram && gnubuckets != NULL)
11640     {
11641       unsigned long * lengths;
11642       unsigned long * counts;
11643       unsigned long hn;
11644       unsigned long maxlength = 0;
11645       unsigned long nzero_counts = 0;
11646       unsigned long nsyms = 0;
11647
11648       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11649               (unsigned long) ngnubuckets);
11650
11651       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11652       if (lengths == NULL)
11653         {
11654           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11655           return FALSE;
11656         }
11657
11658       printf (_(" Length  Number     %% of total  Coverage\n"));
11659
11660       for (hn = 0; hn < ngnubuckets; ++hn)
11661         if (gnubuckets[hn] != 0)
11662           {
11663             bfd_vma off, length = 1;
11664
11665             for (off = gnubuckets[hn] - gnusymidx;
11666                  /* PR 17531 file: 010-77222-0.004.  */
11667                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11668                  ++off)
11669               ++length;
11670             lengths[hn] = length;
11671             if (length > maxlength)
11672               maxlength = length;
11673             nsyms += length;
11674           }
11675
11676       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11677       if (counts == NULL)
11678         {
11679           free (lengths);
11680           error (_("Out of memory allocating space for gnu histogram counts\n"));
11681           return FALSE;
11682         }
11683
11684       for (hn = 0; hn < ngnubuckets; ++hn)
11685         ++counts[lengths[hn]];
11686
11687       if (ngnubuckets > 0)
11688         {
11689           unsigned long j;
11690           printf ("      0  %-10lu (%5.1f%%)\n",
11691                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11692           for (j = 1; j <= maxlength; ++j)
11693             {
11694               nzero_counts += counts[j] * j;
11695               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11696                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11697                       (nzero_counts * 100.0) / nsyms);
11698             }
11699         }
11700
11701       free (counts);
11702       free (lengths);
11703       free (gnubuckets);
11704       free (gnuchains);
11705     }
11706
11707   return TRUE;
11708 }
11709
11710 static bfd_boolean
11711 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11712 {
11713   unsigned int i;
11714
11715   if (dynamic_syminfo == NULL
11716       || !do_dynamic)
11717     /* No syminfo, this is ok.  */
11718     return TRUE;
11719
11720   /* There better should be a dynamic symbol section.  */
11721   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11722     return FALSE;
11723
11724   if (dynamic_addr)
11725     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11726             dynamic_syminfo_offset, dynamic_syminfo_nent);
11727
11728   printf (_(" Num: Name                           BoundTo     Flags\n"));
11729   for (i = 0; i < dynamic_syminfo_nent; ++i)
11730     {
11731       unsigned short int flags = dynamic_syminfo[i].si_flags;
11732
11733       printf ("%4d: ", i);
11734       if (i >= num_dynamic_syms)
11735         printf (_("<corrupt index>"));
11736       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11737         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11738       else
11739         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11740       putchar (' ');
11741
11742       switch (dynamic_syminfo[i].si_boundto)
11743         {
11744         case SYMINFO_BT_SELF:
11745           fputs ("SELF       ", stdout);
11746           break;
11747         case SYMINFO_BT_PARENT:
11748           fputs ("PARENT     ", stdout);
11749           break;
11750         default:
11751           if (dynamic_syminfo[i].si_boundto > 0
11752               && dynamic_syminfo[i].si_boundto < dynamic_nent
11753               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11754             {
11755               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11756               putchar (' ' );
11757             }
11758           else
11759             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11760           break;
11761         }
11762
11763       if (flags & SYMINFO_FLG_DIRECT)
11764         printf (" DIRECT");
11765       if (flags & SYMINFO_FLG_PASSTHRU)
11766         printf (" PASSTHRU");
11767       if (flags & SYMINFO_FLG_COPY)
11768         printf (" COPY");
11769       if (flags & SYMINFO_FLG_LAZYLOAD)
11770         printf (" LAZYLOAD");
11771
11772       puts ("");
11773     }
11774
11775   return TRUE;
11776 }
11777
11778 #define IN_RANGE(START,END,ADDR,OFF)            \
11779   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11780
11781 /* Check to see if the given reloc needs to be handled in a target specific
11782    manner.  If so then process the reloc and return TRUE otherwise return
11783    FALSE.
11784
11785    If called with reloc == NULL, then this is a signal that reloc processing
11786    for the current section has finished, and any saved state should be
11787    discarded.  */
11788
11789 static bfd_boolean
11790 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11791                                 unsigned char *     start,
11792                                 unsigned char *     end,
11793                                 Elf_Internal_Sym *  symtab,
11794                                 unsigned long       num_syms)
11795 {
11796   unsigned int reloc_type = 0;
11797   unsigned long sym_index = 0;
11798
11799   if (reloc)
11800     {
11801       reloc_type = get_reloc_type (reloc->r_info);
11802       sym_index = get_reloc_symindex (reloc->r_info);
11803     }
11804
11805   switch (elf_header.e_machine)
11806     {
11807     case EM_MSP430:
11808     case EM_MSP430_OLD:
11809       {
11810         static Elf_Internal_Sym * saved_sym = NULL;
11811
11812         if (reloc == NULL)
11813           {
11814             saved_sym = NULL;
11815             return TRUE;
11816           }
11817
11818         switch (reloc_type)
11819           {
11820           case 10: /* R_MSP430_SYM_DIFF */
11821             if (uses_msp430x_relocs ())
11822               break;
11823             /* Fall through.  */
11824           case 21: /* R_MSP430X_SYM_DIFF */
11825             /* PR 21139.  */
11826             if (sym_index >= num_syms)
11827               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11828                      sym_index);
11829             else
11830               saved_sym = symtab + sym_index;
11831             return TRUE;
11832
11833           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11834           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11835             goto handle_sym_diff;
11836
11837           case 5: /* R_MSP430_16_BYTE */
11838           case 9: /* R_MSP430_8 */
11839             if (uses_msp430x_relocs ())
11840               break;
11841             goto handle_sym_diff;
11842
11843           case 2: /* R_MSP430_ABS16 */
11844           case 15: /* R_MSP430X_ABS16 */
11845             if (! uses_msp430x_relocs ())
11846               break;
11847             goto handle_sym_diff;
11848
11849           handle_sym_diff:
11850             if (saved_sym != NULL)
11851               {
11852                 int reloc_size = reloc_type == 1 ? 4 : 2;
11853                 bfd_vma value;
11854
11855                 if (sym_index >= num_syms)
11856                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11857                          sym_index);
11858                 else
11859                   {
11860                     value = reloc->r_addend + (symtab[sym_index].st_value
11861                                                - saved_sym->st_value);
11862
11863                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11864                       byte_put (start + reloc->r_offset, value, reloc_size);
11865                     else
11866                       /* PR 21137 */
11867                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11868                              (long) reloc->r_offset);
11869                   }
11870
11871                 saved_sym = NULL;
11872                 return TRUE;
11873               }
11874             break;
11875
11876           default:
11877             if (saved_sym != NULL)
11878               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11879             break;
11880           }
11881         break;
11882       }
11883
11884     case EM_MN10300:
11885     case EM_CYGNUS_MN10300:
11886       {
11887         static Elf_Internal_Sym * saved_sym = NULL;
11888
11889         if (reloc == NULL)
11890           {
11891             saved_sym = NULL;
11892             return TRUE;
11893           }
11894
11895         switch (reloc_type)
11896           {
11897           case 34: /* R_MN10300_ALIGN */
11898             return TRUE;
11899           case 33: /* R_MN10300_SYM_DIFF */
11900             if (sym_index >= num_syms)
11901               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11902                      sym_index);
11903             else
11904               saved_sym = symtab + sym_index;
11905             return TRUE;
11906
11907           case 1: /* R_MN10300_32 */
11908           case 2: /* R_MN10300_16 */
11909             if (saved_sym != NULL)
11910               {
11911                 int reloc_size = reloc_type == 1 ? 4 : 2;
11912                 bfd_vma value;
11913
11914                 if (sym_index >= num_syms)
11915                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11916                          sym_index);
11917                 else
11918                   {
11919                     value = reloc->r_addend + (symtab[sym_index].st_value
11920                                                - saved_sym->st_value);
11921
11922                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11923                       byte_put (start + reloc->r_offset, value, reloc_size);
11924                     else
11925                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11926                              (long) reloc->r_offset);
11927                   }
11928
11929                 saved_sym = NULL;
11930                 return TRUE;
11931               }
11932             break;
11933           default:
11934             if (saved_sym != NULL)
11935               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11936             break;
11937           }
11938         break;
11939       }
11940
11941     case EM_RL78:
11942       {
11943         static bfd_vma saved_sym1 = 0;
11944         static bfd_vma saved_sym2 = 0;
11945         static bfd_vma value;
11946
11947         if (reloc == NULL)
11948           {
11949             saved_sym1 = saved_sym2 = 0;
11950             return TRUE;
11951           }
11952
11953         switch (reloc_type)
11954           {
11955           case 0x80: /* R_RL78_SYM.  */
11956             saved_sym1 = saved_sym2;
11957             if (sym_index >= num_syms)
11958               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11959                      sym_index);
11960             else
11961               {
11962                 saved_sym2 = symtab[sym_index].st_value;
11963                 saved_sym2 += reloc->r_addend;
11964               }
11965             return TRUE;
11966
11967           case 0x83: /* R_RL78_OPsub.  */
11968             value = saved_sym1 - saved_sym2;
11969             saved_sym2 = saved_sym1 = 0;
11970             return TRUE;
11971             break;
11972
11973           case 0x41: /* R_RL78_ABS32.  */
11974             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11975               byte_put (start + reloc->r_offset, value, 4);
11976             else
11977               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11978                      (long) reloc->r_offset);
11979             value = 0;
11980             return TRUE;
11981
11982           case 0x43: /* R_RL78_ABS16.  */
11983             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11984               byte_put (start + reloc->r_offset, value, 2);
11985             else
11986               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11987                      (long) reloc->r_offset);
11988             value = 0;
11989             return TRUE;
11990
11991           default:
11992             break;
11993           }
11994         break;
11995       }
11996     }
11997
11998   return FALSE;
11999 }
12000
12001 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12002    DWARF debug sections.  This is a target specific test.  Note - we do not
12003    go through the whole including-target-headers-multiple-times route, (as
12004    we have already done with <elf/h8.h>) because this would become very
12005    messy and even then this function would have to contain target specific
12006    information (the names of the relocs instead of their numeric values).
12007    FIXME: This is not the correct way to solve this problem.  The proper way
12008    is to have target specific reloc sizing and typing functions created by
12009    the reloc-macros.h header, in the same way that it already creates the
12010    reloc naming functions.  */
12011
12012 static bfd_boolean
12013 is_32bit_abs_reloc (unsigned int reloc_type)
12014 {
12015   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12016   switch (elf_header.e_machine)
12017     {
12018     case EM_386:
12019     case EM_IAMCU:
12020       return reloc_type == 1; /* R_386_32.  */
12021     case EM_68K:
12022       return reloc_type == 1; /* R_68K_32.  */
12023     case EM_860:
12024       return reloc_type == 1; /* R_860_32.  */
12025     case EM_960:
12026       return reloc_type == 2; /* R_960_32.  */
12027     case EM_AARCH64:
12028       return (reloc_type == 258
12029               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12030     case EM_ADAPTEVA_EPIPHANY:
12031       return reloc_type == 3;
12032     case EM_ALPHA:
12033       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12034     case EM_ARC:
12035       return reloc_type == 1; /* R_ARC_32.  */
12036     case EM_ARC_COMPACT:
12037     case EM_ARC_COMPACT2:
12038       return reloc_type == 4; /* R_ARC_32.  */
12039     case EM_ARM:
12040       return reloc_type == 2; /* R_ARM_ABS32 */
12041     case EM_AVR_OLD:
12042     case EM_AVR:
12043       return reloc_type == 1;
12044     case EM_BLACKFIN:
12045       return reloc_type == 0x12; /* R_byte4_data.  */
12046     case EM_CRIS:
12047       return reloc_type == 3; /* R_CRIS_32.  */
12048     case EM_CR16:
12049       return reloc_type == 3; /* R_CR16_NUM32.  */
12050     case EM_CRX:
12051       return reloc_type == 15; /* R_CRX_NUM32.  */
12052     case EM_CYGNUS_FRV:
12053       return reloc_type == 1;
12054     case EM_CYGNUS_D10V:
12055     case EM_D10V:
12056       return reloc_type == 6; /* R_D10V_32.  */
12057     case EM_CYGNUS_D30V:
12058     case EM_D30V:
12059       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12060     case EM_DLX:
12061       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12062     case EM_CYGNUS_FR30:
12063     case EM_FR30:
12064       return reloc_type == 3; /* R_FR30_32.  */
12065     case EM_FT32:
12066       return reloc_type == 1; /* R_FT32_32.  */
12067     case EM_H8S:
12068     case EM_H8_300:
12069     case EM_H8_300H:
12070       return reloc_type == 1; /* R_H8_DIR32.  */
12071     case EM_IA_64:
12072       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12073               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12074               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12075               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12076     case EM_IP2K_OLD:
12077     case EM_IP2K:
12078       return reloc_type == 2; /* R_IP2K_32.  */
12079     case EM_IQ2000:
12080       return reloc_type == 2; /* R_IQ2000_32.  */
12081     case EM_LATTICEMICO32:
12082       return reloc_type == 3; /* R_LM32_32.  */
12083     case EM_M32C_OLD:
12084     case EM_M32C:
12085       return reloc_type == 3; /* R_M32C_32.  */
12086     case EM_M32R:
12087       return reloc_type == 34; /* R_M32R_32_RELA.  */
12088     case EM_68HC11:
12089     case EM_68HC12:
12090       return reloc_type == 6; /* R_M68HC11_32.  */
12091     case EM_MCORE:
12092       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12093     case EM_CYGNUS_MEP:
12094       return reloc_type == 4; /* R_MEP_32.  */
12095     case EM_METAG:
12096       return reloc_type == 2; /* R_METAG_ADDR32.  */
12097     case EM_MICROBLAZE:
12098       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12099     case EM_MIPS:
12100       return reloc_type == 2; /* R_MIPS_32.  */
12101     case EM_MMIX:
12102       return reloc_type == 4; /* R_MMIX_32.  */
12103     case EM_CYGNUS_MN10200:
12104     case EM_MN10200:
12105       return reloc_type == 1; /* R_MN10200_32.  */
12106     case EM_CYGNUS_MN10300:
12107     case EM_MN10300:
12108       return reloc_type == 1; /* R_MN10300_32.  */
12109     case EM_MOXIE:
12110       return reloc_type == 1; /* R_MOXIE_32.  */
12111     case EM_MSP430_OLD:
12112     case EM_MSP430:
12113       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12114     case EM_MT:
12115       return reloc_type == 2; /* R_MT_32.  */
12116     case EM_NDS32:
12117       return reloc_type == 20; /* R_NDS32_RELA.  */
12118     case EM_ALTERA_NIOS2:
12119       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12120     case EM_NIOS32:
12121       return reloc_type == 1; /* R_NIOS_32.  */
12122     case EM_OR1K:
12123       return reloc_type == 1; /* R_OR1K_32.  */
12124     case EM_PARISC:
12125       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12126               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12127     case EM_PJ:
12128     case EM_PJ_OLD:
12129       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12130     case EM_PPC64:
12131       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12132     case EM_PPC:
12133       return reloc_type == 1; /* R_PPC_ADDR32.  */
12134     case EM_TI_PRU:
12135       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12136     case EM_RISCV:
12137       return reloc_type == 1; /* R_RISCV_32.  */
12138     case EM_RL78:
12139       return reloc_type == 1; /* R_RL78_DIR32.  */
12140     case EM_RX:
12141       return reloc_type == 1; /* R_RX_DIR32.  */
12142     case EM_S370:
12143       return reloc_type == 1; /* R_I370_ADDR31.  */
12144     case EM_S390_OLD:
12145     case EM_S390:
12146       return reloc_type == 4; /* R_S390_32.  */
12147     case EM_SCORE:
12148       return reloc_type == 8; /* R_SCORE_ABS32.  */
12149     case EM_SH:
12150       return reloc_type == 1; /* R_SH_DIR32.  */
12151     case EM_SPARC32PLUS:
12152     case EM_SPARCV9:
12153     case EM_SPARC:
12154       return reloc_type == 3 /* R_SPARC_32.  */
12155         || reloc_type == 23; /* R_SPARC_UA32.  */
12156     case EM_SPU:
12157       return reloc_type == 6; /* R_SPU_ADDR32 */
12158     case EM_TI_C6000:
12159       return reloc_type == 1; /* R_C6000_ABS32.  */
12160     case EM_TILEGX:
12161       return reloc_type == 2; /* R_TILEGX_32.  */
12162     case EM_TILEPRO:
12163       return reloc_type == 1; /* R_TILEPRO_32.  */
12164     case EM_CYGNUS_V850:
12165     case EM_V850:
12166       return reloc_type == 6; /* R_V850_ABS32.  */
12167     case EM_V800:
12168       return reloc_type == 0x33; /* R_V810_WORD.  */
12169     case EM_VAX:
12170       return reloc_type == 1; /* R_VAX_32.  */
12171     case EM_VISIUM:
12172       return reloc_type == 3;  /* R_VISIUM_32. */
12173     case EM_WEBASSEMBLY:
12174       return reloc_type == 1;  /* R_WASM32_32.  */
12175     case EM_X86_64:
12176     case EM_L1OM:
12177     case EM_K1OM:
12178       return reloc_type == 10; /* R_X86_64_32.  */
12179     case EM_XC16X:
12180     case EM_C166:
12181       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12182     case EM_XGATE:
12183       return reloc_type == 4; /* R_XGATE_32.  */
12184     case EM_XSTORMY16:
12185       return reloc_type == 1; /* R_XSTROMY16_32.  */
12186     case EM_XTENSA_OLD:
12187     case EM_XTENSA:
12188       return reloc_type == 1; /* R_XTENSA_32.  */
12189     default:
12190       {
12191         static unsigned int prev_warn = 0;
12192
12193         /* Avoid repeating the same warning multiple times.  */
12194         if (prev_warn != elf_header.e_machine)
12195           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12196                  elf_header.e_machine);
12197         prev_warn = elf_header.e_machine;
12198         return FALSE;
12199       }
12200     }
12201 }
12202
12203 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12204    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12205
12206 static bfd_boolean
12207 is_32bit_pcrel_reloc (unsigned int reloc_type)
12208 {
12209   switch (elf_header.e_machine)
12210   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12211     {
12212     case EM_386:
12213     case EM_IAMCU:
12214       return reloc_type == 2;  /* R_386_PC32.  */
12215     case EM_68K:
12216       return reloc_type == 4;  /* R_68K_PC32.  */
12217     case EM_AARCH64:
12218       return reloc_type == 261; /* R_AARCH64_PREL32 */
12219     case EM_ADAPTEVA_EPIPHANY:
12220       return reloc_type == 6;
12221     case EM_ALPHA:
12222       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12223     case EM_ARC_COMPACT:
12224     case EM_ARC_COMPACT2:
12225       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12226     case EM_ARM:
12227       return reloc_type == 3;  /* R_ARM_REL32 */
12228     case EM_AVR_OLD:
12229     case EM_AVR:
12230       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12231     case EM_MICROBLAZE:
12232       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12233     case EM_OR1K:
12234       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12235     case EM_PARISC:
12236       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12237     case EM_PPC:
12238       return reloc_type == 26; /* R_PPC_REL32.  */
12239     case EM_PPC64:
12240       return reloc_type == 26; /* R_PPC64_REL32.  */
12241     case EM_S390_OLD:
12242     case EM_S390:
12243       return reloc_type == 5;  /* R_390_PC32.  */
12244     case EM_SH:
12245       return reloc_type == 2;  /* R_SH_REL32.  */
12246     case EM_SPARC32PLUS:
12247     case EM_SPARCV9:
12248     case EM_SPARC:
12249       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12250     case EM_SPU:
12251       return reloc_type == 13; /* R_SPU_REL32.  */
12252     case EM_TILEGX:
12253       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12254     case EM_TILEPRO:
12255       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12256     case EM_VISIUM:
12257       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12258     case EM_X86_64:
12259     case EM_L1OM:
12260     case EM_K1OM:
12261       return reloc_type == 2;  /* R_X86_64_PC32.  */
12262     case EM_XTENSA_OLD:
12263     case EM_XTENSA:
12264       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12265     default:
12266       /* Do not abort or issue an error message here.  Not all targets use
12267          pc-relative 32-bit relocs in their DWARF debug information and we
12268          have already tested for target coverage in is_32bit_abs_reloc.  A
12269          more helpful warning message will be generated by apply_relocations
12270          anyway, so just return.  */
12271       return FALSE;
12272     }
12273 }
12274
12275 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12276    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12277
12278 static bfd_boolean
12279 is_64bit_abs_reloc (unsigned int reloc_type)
12280 {
12281   switch (elf_header.e_machine)
12282     {
12283     case EM_AARCH64:
12284       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12285     case EM_ALPHA:
12286       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12287     case EM_IA_64:
12288       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12289               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12290     case EM_PARISC:
12291       return reloc_type == 80; /* R_PARISC_DIR64.  */
12292     case EM_PPC64:
12293       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12294     case EM_RISCV:
12295       return reloc_type == 2; /* R_RISCV_64.  */
12296     case EM_SPARC32PLUS:
12297     case EM_SPARCV9:
12298     case EM_SPARC:
12299       return reloc_type == 32 /* R_SPARC_64.  */
12300         || reloc_type == 54; /* R_SPARC_UA64.  */
12301     case EM_X86_64:
12302     case EM_L1OM:
12303     case EM_K1OM:
12304       return reloc_type == 1; /* R_X86_64_64.  */
12305     case EM_S390_OLD:
12306     case EM_S390:
12307       return reloc_type == 22;  /* R_S390_64.  */
12308     case EM_TILEGX:
12309       return reloc_type == 1; /* R_TILEGX_64.  */
12310     case EM_MIPS:
12311       return reloc_type == 18;  /* R_MIPS_64.  */
12312     default:
12313       return FALSE;
12314     }
12315 }
12316
12317 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12318    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12319
12320 static bfd_boolean
12321 is_64bit_pcrel_reloc (unsigned int reloc_type)
12322 {
12323   switch (elf_header.e_machine)
12324     {
12325     case EM_AARCH64:
12326       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12327     case EM_ALPHA:
12328       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12329     case EM_IA_64:
12330       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12331               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12332     case EM_PARISC:
12333       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12334     case EM_PPC64:
12335       return reloc_type == 44; /* R_PPC64_REL64.  */
12336     case EM_SPARC32PLUS:
12337     case EM_SPARCV9:
12338     case EM_SPARC:
12339       return reloc_type == 46; /* R_SPARC_DISP64.  */
12340     case EM_X86_64:
12341     case EM_L1OM:
12342     case EM_K1OM:
12343       return reloc_type == 24; /* R_X86_64_PC64.  */
12344     case EM_S390_OLD:
12345     case EM_S390:
12346       return reloc_type == 23;  /* R_S390_PC64.  */
12347     case EM_TILEGX:
12348       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12349     default:
12350       return FALSE;
12351     }
12352 }
12353
12354 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12355    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12356
12357 static bfd_boolean
12358 is_24bit_abs_reloc (unsigned int reloc_type)
12359 {
12360   switch (elf_header.e_machine)
12361     {
12362     case EM_CYGNUS_MN10200:
12363     case EM_MN10200:
12364       return reloc_type == 4; /* R_MN10200_24.  */
12365     case EM_FT32:
12366       return reloc_type == 5; /* R_FT32_20.  */
12367     default:
12368       return FALSE;
12369     }
12370 }
12371
12372 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12373    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12374
12375 static bfd_boolean
12376 is_16bit_abs_reloc (unsigned int reloc_type)
12377 {
12378   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12379   switch (elf_header.e_machine)
12380     {
12381     case EM_ARC:
12382     case EM_ARC_COMPACT:
12383     case EM_ARC_COMPACT2:
12384       return reloc_type == 2; /* R_ARC_16.  */
12385     case EM_ADAPTEVA_EPIPHANY:
12386       return reloc_type == 5;
12387     case EM_AVR_OLD:
12388     case EM_AVR:
12389       return reloc_type == 4; /* R_AVR_16.  */
12390     case EM_CYGNUS_D10V:
12391     case EM_D10V:
12392       return reloc_type == 3; /* R_D10V_16.  */
12393     case EM_H8S:
12394     case EM_H8_300:
12395     case EM_H8_300H:
12396       return reloc_type == R_H8_DIR16;
12397     case EM_IP2K_OLD:
12398     case EM_IP2K:
12399       return reloc_type == 1; /* R_IP2K_16.  */
12400     case EM_M32C_OLD:
12401     case EM_M32C:
12402       return reloc_type == 1; /* R_M32C_16 */
12403     case EM_CYGNUS_MN10200:
12404     case EM_MN10200:
12405       return reloc_type == 2; /* R_MN10200_16.  */
12406     case EM_CYGNUS_MN10300:
12407     case EM_MN10300:
12408       return reloc_type == 2; /* R_MN10300_16.  */
12409     case EM_MSP430:
12410       if (uses_msp430x_relocs ())
12411         return reloc_type == 2; /* R_MSP430_ABS16.  */
12412       /* Fall through.  */
12413     case EM_MSP430_OLD:
12414       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12415     case EM_NDS32:
12416       return reloc_type == 19; /* R_NDS32_RELA.  */
12417     case EM_ALTERA_NIOS2:
12418       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12419     case EM_NIOS32:
12420       return reloc_type == 9; /* R_NIOS_16.  */
12421     case EM_OR1K:
12422       return reloc_type == 2; /* R_OR1K_16.  */
12423     case EM_TI_PRU:
12424       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12425     case EM_TI_C6000:
12426       return reloc_type == 2; /* R_C6000_ABS16.  */
12427     case EM_VISIUM:
12428       return reloc_type == 2; /* R_VISIUM_16. */
12429     case EM_XC16X:
12430     case EM_C166:
12431       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12432     case EM_XGATE:
12433       return reloc_type == 3; /* R_XGATE_16.  */
12434     default:
12435       return FALSE;
12436     }
12437 }
12438
12439 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12440    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12441
12442 static bfd_boolean
12443 is_none_reloc (unsigned int reloc_type)
12444 {
12445   switch (elf_header.e_machine)
12446     {
12447     case EM_386:     /* R_386_NONE.  */
12448     case EM_68K:     /* R_68K_NONE.  */
12449     case EM_ADAPTEVA_EPIPHANY:
12450     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12451     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12452     case EM_ARC:     /* R_ARC_NONE.  */
12453     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12454     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12455     case EM_ARM:     /* R_ARM_NONE.  */
12456     case EM_C166:    /* R_XC16X_NONE.  */
12457     case EM_CRIS:    /* R_CRIS_NONE.  */
12458     case EM_FT32:    /* R_FT32_NONE.  */
12459     case EM_IA_64:   /* R_IA64_NONE.  */
12460     case EM_K1OM:    /* R_X86_64_NONE.  */
12461     case EM_L1OM:    /* R_X86_64_NONE.  */
12462     case EM_M32R:    /* R_M32R_NONE.  */
12463     case EM_MIPS:    /* R_MIPS_NONE.  */
12464     case EM_MN10300: /* R_MN10300_NONE.  */
12465     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12466     case EM_NIOS32:  /* R_NIOS_NONE.  */
12467     case EM_OR1K:    /* R_OR1K_NONE. */
12468     case EM_PARISC:  /* R_PARISC_NONE.  */
12469     case EM_PPC64:   /* R_PPC64_NONE.  */
12470     case EM_PPC:     /* R_PPC_NONE.  */
12471     case EM_RISCV:   /* R_RISCV_NONE.  */
12472     case EM_S390:    /* R_390_NONE.  */
12473     case EM_S390_OLD:
12474     case EM_SH:      /* R_SH_NONE.  */
12475     case EM_SPARC32PLUS:
12476     case EM_SPARC:   /* R_SPARC_NONE.  */
12477     case EM_SPARCV9:
12478     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12479     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12480     case EM_TI_C6000:/* R_C6000_NONE.  */
12481     case EM_X86_64:  /* R_X86_64_NONE.  */
12482     case EM_XC16X:
12483     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12484       return reloc_type == 0;
12485
12486     case EM_AARCH64:
12487       return reloc_type == 0 || reloc_type == 256;
12488     case EM_AVR_OLD:
12489     case EM_AVR:
12490       return (reloc_type == 0 /* R_AVR_NONE.  */
12491               || reloc_type == 30 /* R_AVR_DIFF8.  */
12492               || reloc_type == 31 /* R_AVR_DIFF16.  */
12493               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12494     case EM_METAG:
12495       return reloc_type == 3; /* R_METAG_NONE.  */
12496     case EM_NDS32:
12497       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12498               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12499               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12500               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12501               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12502     case EM_TI_PRU:
12503       return (reloc_type == 0       /* R_PRU_NONE.  */
12504               || reloc_type == 65   /* R_PRU_DIFF8.  */
12505               || reloc_type == 66   /* R_PRU_DIFF16.  */
12506               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12507     case EM_XTENSA_OLD:
12508     case EM_XTENSA:
12509       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12510               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12511               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12512               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12513     }
12514   return FALSE;
12515 }
12516
12517 /* Returns TRUE if there is a relocation against
12518    section NAME at OFFSET bytes.  */
12519
12520 bfd_boolean
12521 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12522 {
12523   Elf_Internal_Rela * relocs;
12524   Elf_Internal_Rela * rp;
12525
12526   if (dsec == NULL || dsec->reloc_info == NULL)
12527     return FALSE;
12528
12529   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12530
12531   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12532     if (rp->r_offset == offset)
12533       return TRUE;
12534
12535    return FALSE;
12536 }
12537
12538 /* Apply relocations to a section.
12539    Returns TRUE upon success, FALSE otherwise.
12540    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12541    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12542    will be set to the number of relocs loaded.
12543
12544    Note: So far support has been added only for those relocations
12545    which can be found in debug sections. FIXME: Add support for
12546    more relocations ?  */
12547
12548 static bfd_boolean
12549 apply_relocations (void *                     file,
12550                    const Elf_Internal_Shdr *  section,
12551                    unsigned char *            start,
12552                    bfd_size_type              size,
12553                    void **                    relocs_return,
12554                    unsigned long *            num_relocs_return)
12555 {
12556   Elf_Internal_Shdr * relsec;
12557   unsigned char * end = start + size;
12558   bfd_boolean res = TRUE;
12559
12560   if (relocs_return != NULL)
12561     {
12562       * (Elf_Internal_Rela **) relocs_return = NULL;
12563       * num_relocs_return = 0;
12564     }
12565
12566   if (elf_header.e_type != ET_REL)
12567     /* No relocs to apply.  */
12568     return TRUE;
12569
12570   /* Find the reloc section associated with the section.  */
12571   for (relsec = section_headers;
12572        relsec < section_headers + elf_header.e_shnum;
12573        ++relsec)
12574     {
12575       bfd_boolean is_rela;
12576       unsigned long num_relocs;
12577       Elf_Internal_Rela * relocs;
12578       Elf_Internal_Rela * rp;
12579       Elf_Internal_Shdr * symsec;
12580       Elf_Internal_Sym * symtab;
12581       unsigned long num_syms;
12582       Elf_Internal_Sym * sym;
12583
12584       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12585           || relsec->sh_info >= elf_header.e_shnum
12586           || section_headers + relsec->sh_info != section
12587           || relsec->sh_size == 0
12588           || relsec->sh_link >= elf_header.e_shnum)
12589         continue;
12590
12591       is_rela = relsec->sh_type == SHT_RELA;
12592
12593       if (is_rela)
12594         {
12595           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12596                                   relsec->sh_size, & relocs, & num_relocs))
12597             return FALSE;
12598         }
12599       else
12600         {
12601           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12602                                  relsec->sh_size, & relocs, & num_relocs))
12603             return FALSE;
12604         }
12605
12606       /* SH uses RELA but uses in place value instead of the addend field.  */
12607       if (elf_header.e_machine == EM_SH)
12608         is_rela = FALSE;
12609
12610       symsec = section_headers + relsec->sh_link;
12611       if (symsec->sh_type != SHT_SYMTAB
12612           && symsec->sh_type != SHT_DYNSYM)
12613         return FALSE;
12614       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12615
12616       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12617         {
12618           bfd_vma         addend;
12619           unsigned int    reloc_type;
12620           unsigned int    reloc_size;
12621           unsigned char * rloc;
12622           unsigned long   sym_index;
12623
12624           reloc_type = get_reloc_type (rp->r_info);
12625
12626           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12627             continue;
12628           else if (is_none_reloc (reloc_type))
12629             continue;
12630           else if (is_32bit_abs_reloc (reloc_type)
12631                    || is_32bit_pcrel_reloc (reloc_type))
12632             reloc_size = 4;
12633           else if (is_64bit_abs_reloc (reloc_type)
12634                    || is_64bit_pcrel_reloc (reloc_type))
12635             reloc_size = 8;
12636           else if (is_24bit_abs_reloc (reloc_type))
12637             reloc_size = 3;
12638           else if (is_16bit_abs_reloc (reloc_type))
12639             reloc_size = 2;
12640           else
12641             {
12642               static unsigned int prev_reloc = 0;
12643               if (reloc_type != prev_reloc)
12644                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12645                       reloc_type, printable_section_name (section));
12646               prev_reloc = reloc_type;
12647               res = FALSE;
12648               continue;
12649             }
12650
12651           rloc = start + rp->r_offset;
12652           if ((rloc + reloc_size) > end || (rloc < start))
12653             {
12654               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12655                     (unsigned long) rp->r_offset,
12656                     printable_section_name (section));
12657               res = FALSE;
12658               continue;
12659             }
12660
12661           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12662           if (sym_index >= num_syms)
12663             {
12664               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12665                     sym_index, printable_section_name (section));
12666               res = FALSE;
12667               continue;
12668             }
12669           sym = symtab + sym_index;
12670
12671           /* If the reloc has a symbol associated with it,
12672              make sure that it is of an appropriate type.
12673
12674              Relocations against symbols without type can happen.
12675              Gcc -feliminate-dwarf2-dups may generate symbols
12676              without type for debug info.
12677
12678              Icc generates relocations against function symbols
12679              instead of local labels.
12680
12681              Relocations against object symbols can happen, eg when
12682              referencing a global array.  For an example of this see
12683              the _clz.o binary in libgcc.a.  */
12684           if (sym != symtab
12685               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12686               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12687             {
12688               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12689                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12690                     (long int)(rp - relocs),
12691                     printable_section_name (relsec));
12692               res = FALSE;
12693               continue;
12694             }
12695
12696           addend = 0;
12697           if (is_rela)
12698             addend += rp->r_addend;
12699           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12700              partial_inplace.  */
12701           if (!is_rela
12702               || (elf_header.e_machine == EM_XTENSA
12703                   && reloc_type == 1)
12704               || ((elf_header.e_machine == EM_PJ
12705                    || elf_header.e_machine == EM_PJ_OLD)
12706                   && reloc_type == 1)
12707               || ((elf_header.e_machine == EM_D30V
12708                    || elf_header.e_machine == EM_CYGNUS_D30V)
12709                   && reloc_type == 12))
12710             addend += byte_get (rloc, reloc_size);
12711
12712           if (is_32bit_pcrel_reloc (reloc_type)
12713               || is_64bit_pcrel_reloc (reloc_type))
12714             {
12715               /* On HPPA, all pc-relative relocations are biased by 8.  */
12716               if (elf_header.e_machine == EM_PARISC)
12717                 addend -= 8;
12718               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12719                         reloc_size);
12720             }
12721           else
12722             byte_put (rloc, addend + sym->st_value, reloc_size);
12723         }
12724
12725       free (symtab);
12726       /* Let the target specific reloc processing code know that
12727          we have finished with these relocs.  */
12728       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12729
12730       if (relocs_return)
12731         {
12732           * (Elf_Internal_Rela **) relocs_return = relocs;
12733           * num_relocs_return = num_relocs;
12734         }
12735       else
12736         free (relocs);
12737
12738       break;
12739     }
12740
12741   return res;
12742 }
12743
12744 #ifdef SUPPORT_DISASSEMBLY
12745 static bfd_boolean
12746 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12747 {
12748   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12749
12750   /* FIXME: XXX -- to be done --- XXX */
12751
12752   return TRUE;
12753 }
12754 #endif
12755
12756 /* Reads in the contents of SECTION from FILE, returning a pointer
12757    to a malloc'ed buffer or NULL if something went wrong.  */
12758
12759 static char *
12760 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12761 {
12762   bfd_size_type num_bytes;
12763
12764   num_bytes = section->sh_size;
12765
12766   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12767     {
12768       printf (_("Section '%s' has no data to dump.\n"),
12769               printable_section_name (section));
12770       return NULL;
12771     }
12772
12773   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12774                              _("section contents"));
12775 }
12776
12777 /* Uncompresses a section that was compressed using zlib, in place.  */
12778
12779 static bfd_boolean
12780 uncompress_section_contents (unsigned char **buffer,
12781                              dwarf_size_type uncompressed_size,
12782                              dwarf_size_type *size)
12783 {
12784   dwarf_size_type compressed_size = *size;
12785   unsigned char * compressed_buffer = *buffer;
12786   unsigned char * uncompressed_buffer;
12787   z_stream strm;
12788   int rc;
12789
12790   /* It is possible the section consists of several compressed
12791      buffers concatenated together, so we uncompress in a loop.  */
12792   /* PR 18313: The state field in the z_stream structure is supposed
12793      to be invisible to the user (ie us), but some compilers will
12794      still complain about it being used without initialisation.  So
12795      we first zero the entire z_stream structure and then set the fields
12796      that we need.  */
12797   memset (& strm, 0, sizeof strm);
12798   strm.avail_in = compressed_size;
12799   strm.next_in = (Bytef *) compressed_buffer;
12800   strm.avail_out = uncompressed_size;
12801   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12802
12803   rc = inflateInit (& strm);
12804   while (strm.avail_in > 0)
12805     {
12806       if (rc != Z_OK)
12807         goto fail;
12808       strm.next_out = ((Bytef *) uncompressed_buffer
12809                        + (uncompressed_size - strm.avail_out));
12810       rc = inflate (&strm, Z_FINISH);
12811       if (rc != Z_STREAM_END)
12812         goto fail;
12813       rc = inflateReset (& strm);
12814     }
12815   rc = inflateEnd (& strm);
12816   if (rc != Z_OK
12817       || strm.avail_out != 0)
12818     goto fail;
12819
12820   *buffer = uncompressed_buffer;
12821   *size = uncompressed_size;
12822   return TRUE;
12823
12824  fail:
12825   free (uncompressed_buffer);
12826   /* Indicate decompression failure.  */
12827   *buffer = NULL;
12828   return FALSE;
12829 }
12830
12831 static bfd_boolean
12832 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12833 {
12834   Elf_Internal_Shdr *  relsec;
12835   bfd_size_type        num_bytes;
12836   unsigned char *      data;
12837   unsigned char *      end;
12838   unsigned char *      real_start;
12839   unsigned char *      start;
12840   bfd_boolean          some_strings_shown;
12841
12842   real_start = start = (unsigned char *) get_section_contents (section, file);
12843   if (start == NULL)
12844     /* PR 21820: Do not fail if the section was empty.  */
12845     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12846
12847   num_bytes = section->sh_size;
12848
12849   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12850
12851   if (decompress_dumps)
12852     {
12853       dwarf_size_type new_size = num_bytes;
12854       dwarf_size_type uncompressed_size = 0;
12855
12856       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12857         {
12858           Elf_Internal_Chdr chdr;
12859           unsigned int compression_header_size
12860             = get_compression_header (& chdr, (unsigned char *) start,
12861                                       num_bytes);
12862
12863           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12864             {
12865               warn (_("section '%s' has unsupported compress type: %d\n"),
12866                     printable_section_name (section), chdr.ch_type);
12867               return FALSE;
12868             }
12869           else if (chdr.ch_addralign != section->sh_addralign)
12870             {
12871               warn (_("compressed section '%s' is corrupted\n"),
12872                     printable_section_name (section));
12873               return FALSE;
12874             }
12875           uncompressed_size = chdr.ch_size;
12876           start += compression_header_size;
12877           new_size -= compression_header_size;
12878         }
12879       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12880         {
12881           /* Read the zlib header.  In this case, it should be "ZLIB"
12882              followed by the uncompressed section size, 8 bytes in
12883              big-endian order.  */
12884           uncompressed_size = start[4]; uncompressed_size <<= 8;
12885           uncompressed_size += start[5]; uncompressed_size <<= 8;
12886           uncompressed_size += start[6]; uncompressed_size <<= 8;
12887           uncompressed_size += start[7]; uncompressed_size <<= 8;
12888           uncompressed_size += start[8]; uncompressed_size <<= 8;
12889           uncompressed_size += start[9]; uncompressed_size <<= 8;
12890           uncompressed_size += start[10]; uncompressed_size <<= 8;
12891           uncompressed_size += start[11];
12892           start += 12;
12893           new_size -= 12;
12894         }
12895
12896       if (uncompressed_size)
12897         {
12898           if (uncompress_section_contents (& start,
12899                                            uncompressed_size, & new_size))
12900             num_bytes = new_size;
12901           else
12902             {
12903               error (_("Unable to decompress section %s\n"),
12904                      printable_section_name (section));
12905               return FALSE;
12906             }
12907         }
12908       else
12909         start = real_start;
12910     }
12911
12912   /* If the section being dumped has relocations against it the user might
12913      be expecting these relocations to have been applied.  Check for this
12914      case and issue a warning message in order to avoid confusion.
12915      FIXME: Maybe we ought to have an option that dumps a section with
12916      relocs applied ?  */
12917   for (relsec = section_headers;
12918        relsec < section_headers + elf_header.e_shnum;
12919        ++relsec)
12920     {
12921       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12922           || relsec->sh_info >= elf_header.e_shnum
12923           || section_headers + relsec->sh_info != section
12924           || relsec->sh_size == 0
12925           || relsec->sh_link >= elf_header.e_shnum)
12926         continue;
12927
12928       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12929       break;
12930     }
12931
12932   data = start;
12933   end  = start + num_bytes;
12934   some_strings_shown = FALSE;
12935
12936   while (data < end)
12937     {
12938       while (!ISPRINT (* data))
12939         if (++ data >= end)
12940           break;
12941
12942       if (data < end)
12943         {
12944           size_t maxlen = end - data;
12945
12946 #ifndef __MSVCRT__
12947           /* PR 11128: Use two separate invocations in order to work
12948              around bugs in the Solaris 8 implementation of printf.  */
12949           printf ("  [%6tx]  ", data - start);
12950 #else
12951           printf ("  [%6Ix]  ", (size_t) (data - start));
12952 #endif
12953           if (maxlen > 0)
12954             {
12955               print_symbol ((int) maxlen, (const char *) data);
12956               putchar ('\n');
12957               data += strnlen ((const char *) data, maxlen);
12958             }
12959           else
12960             {
12961               printf (_("<corrupt>\n"));
12962               data = end;
12963             }
12964           some_strings_shown = TRUE;
12965         }
12966     }
12967
12968   if (! some_strings_shown)
12969     printf (_("  No strings found in this section."));
12970
12971   free (real_start);
12972
12973   putchar ('\n');
12974   return TRUE;
12975 }
12976
12977 static bfd_boolean
12978 dump_section_as_bytes (Elf_Internal_Shdr * section,
12979                        FILE * file,
12980                        bfd_boolean relocate)
12981 {
12982   Elf_Internal_Shdr * relsec;
12983   bfd_size_type       bytes;
12984   bfd_size_type       section_size;
12985   bfd_vma             addr;
12986   unsigned char *     data;
12987   unsigned char *     real_start;
12988   unsigned char *     start;
12989
12990   real_start = start = (unsigned char *) get_section_contents (section, file);
12991   if (start == NULL)
12992     /* PR 21820: Do not fail if the section was empty.  */
12993     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12994
12995   section_size = section->sh_size;
12996
12997   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12998
12999   if (decompress_dumps)
13000     {
13001       dwarf_size_type new_size = section_size;
13002       dwarf_size_type uncompressed_size = 0;
13003
13004       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13005         {
13006           Elf_Internal_Chdr chdr;
13007           unsigned int compression_header_size
13008             = get_compression_header (& chdr, start, section_size);
13009
13010           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13011             {
13012               warn (_("section '%s' has unsupported compress type: %d\n"),
13013                     printable_section_name (section), chdr.ch_type);
13014               return FALSE;
13015             }
13016           else if (chdr.ch_addralign != section->sh_addralign)
13017             {
13018               warn (_("compressed section '%s' is corrupted\n"),
13019                     printable_section_name (section));
13020               return FALSE;
13021             }
13022           uncompressed_size = chdr.ch_size;
13023           start += compression_header_size;
13024           new_size -= compression_header_size;
13025         }
13026       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13027         {
13028           /* Read the zlib header.  In this case, it should be "ZLIB"
13029              followed by the uncompressed section size, 8 bytes in
13030              big-endian order.  */
13031           uncompressed_size = start[4]; uncompressed_size <<= 8;
13032           uncompressed_size += start[5]; uncompressed_size <<= 8;
13033           uncompressed_size += start[6]; uncompressed_size <<= 8;
13034           uncompressed_size += start[7]; uncompressed_size <<= 8;
13035           uncompressed_size += start[8]; uncompressed_size <<= 8;
13036           uncompressed_size += start[9]; uncompressed_size <<= 8;
13037           uncompressed_size += start[10]; uncompressed_size <<= 8;
13038           uncompressed_size += start[11];
13039           start += 12;
13040           new_size -= 12;
13041         }
13042
13043       if (uncompressed_size)
13044         {
13045           if (uncompress_section_contents (& start, uncompressed_size,
13046                                            & new_size))
13047             {
13048               section_size = new_size;
13049             }
13050           else
13051             {
13052               error (_("Unable to decompress section %s\n"),
13053                      printable_section_name (section));
13054               /* FIXME: Print the section anyway ?  */
13055               return FALSE;
13056             }
13057         }
13058       else
13059         start = real_start;
13060     }
13061
13062   if (relocate)
13063     {
13064       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13065         return FALSE;
13066     }
13067   else
13068     {
13069       /* If the section being dumped has relocations against it the user might
13070          be expecting these relocations to have been applied.  Check for this
13071          case and issue a warning message in order to avoid confusion.
13072          FIXME: Maybe we ought to have an option that dumps a section with
13073          relocs applied ?  */
13074       for (relsec = section_headers;
13075            relsec < section_headers + elf_header.e_shnum;
13076            ++relsec)
13077         {
13078           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13079               || relsec->sh_info >= elf_header.e_shnum
13080               || section_headers + relsec->sh_info != section
13081               || relsec->sh_size == 0
13082               || relsec->sh_link >= elf_header.e_shnum)
13083             continue;
13084
13085           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13086           break;
13087         }
13088     }
13089
13090   addr = section->sh_addr;
13091   bytes = section_size;
13092   data = start;
13093
13094   while (bytes)
13095     {
13096       int j;
13097       int k;
13098       int lbytes;
13099
13100       lbytes = (bytes > 16 ? 16 : bytes);
13101
13102       printf ("  0x%8.8lx ", (unsigned long) addr);
13103
13104       for (j = 0; j < 16; j++)
13105         {
13106           if (j < lbytes)
13107             printf ("%2.2x", data[j]);
13108           else
13109             printf ("  ");
13110
13111           if ((j & 3) == 3)
13112             printf (" ");
13113         }
13114
13115       for (j = 0; j < lbytes; j++)
13116         {
13117           k = data[j];
13118           if (k >= ' ' && k < 0x7f)
13119             printf ("%c", k);
13120           else
13121             printf (".");
13122         }
13123
13124       putchar ('\n');
13125
13126       data  += lbytes;
13127       addr  += lbytes;
13128       bytes -= lbytes;
13129     }
13130
13131   free (real_start);
13132
13133   putchar ('\n');
13134   return TRUE;
13135 }
13136
13137 static bfd_boolean
13138 load_specific_debug_section (enum dwarf_section_display_enum debug,
13139                              const Elf_Internal_Shdr * sec, void * file)
13140 {
13141   struct dwarf_section * section = &debug_displays [debug].section;
13142   char buf [64];
13143
13144   /* If it is already loaded, do nothing.  */
13145   if (section->start != NULL)
13146     return TRUE;
13147
13148   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13149   section->address = sec->sh_addr;
13150   section->user_data = NULL;
13151   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13152                                                sec->sh_offset, 1,
13153                                                sec->sh_size, buf);
13154   if (section->start == NULL)
13155     section->size = 0;
13156   else
13157     {
13158       unsigned char *start = section->start;
13159       dwarf_size_type size = sec->sh_size;
13160       dwarf_size_type uncompressed_size = 0;
13161
13162       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13163         {
13164           Elf_Internal_Chdr chdr;
13165           unsigned int compression_header_size;
13166
13167           if (size < (is_32bit_elf
13168                       ? sizeof (Elf32_External_Chdr)
13169                       : sizeof (Elf64_External_Chdr)))
13170             {
13171               warn (_("compressed section %s is too small to contain a compression header"),
13172                     section->name);
13173               return FALSE;
13174             }
13175
13176           compression_header_size = get_compression_header (&chdr, start, size);
13177
13178           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13179             {
13180               warn (_("section '%s' has unsupported compress type: %d\n"),
13181                     section->name, chdr.ch_type);
13182               return FALSE;
13183             }
13184           else if (chdr.ch_addralign != sec->sh_addralign)
13185             {
13186               warn (_("compressed section '%s' is corrupted\n"),
13187                     section->name);
13188               return FALSE;
13189             }
13190           uncompressed_size = chdr.ch_size;
13191           start += compression_header_size;
13192           size -= compression_header_size;
13193         }
13194       else if (size > 12 && streq ((char *) start, "ZLIB"))
13195         {
13196           /* Read the zlib header.  In this case, it should be "ZLIB"
13197              followed by the uncompressed section size, 8 bytes in
13198              big-endian order.  */
13199           uncompressed_size = start[4]; uncompressed_size <<= 8;
13200           uncompressed_size += start[5]; uncompressed_size <<= 8;
13201           uncompressed_size += start[6]; uncompressed_size <<= 8;
13202           uncompressed_size += start[7]; uncompressed_size <<= 8;
13203           uncompressed_size += start[8]; uncompressed_size <<= 8;
13204           uncompressed_size += start[9]; uncompressed_size <<= 8;
13205           uncompressed_size += start[10]; uncompressed_size <<= 8;
13206           uncompressed_size += start[11];
13207           start += 12;
13208           size -= 12;
13209         }
13210
13211       if (uncompressed_size)
13212         {
13213           if (uncompress_section_contents (&start, uncompressed_size,
13214                                            &size))
13215             {
13216               /* Free the compressed buffer, update the section buffer
13217                  and the section size if uncompress is successful.  */
13218               free (section->start);
13219               section->start = start;
13220             }
13221           else
13222             {
13223               error (_("Unable to decompress section %s\n"),
13224                      printable_section_name (sec));
13225               return FALSE;
13226             }
13227         }
13228
13229       section->size = size;
13230     }
13231
13232   if (section->start == NULL)
13233     return FALSE;
13234
13235   if (debug_displays [debug].relocate)
13236     {
13237       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13238                                & section->reloc_info, & section->num_relocs))
13239         return FALSE;
13240     }
13241   else
13242     {
13243       section->reloc_info = NULL;
13244       section->num_relocs = 0;
13245     }
13246
13247   return TRUE;
13248 }
13249
13250 /* If this is not NULL, load_debug_section will only look for sections
13251    within the list of sections given here.  */
13252 static unsigned int * section_subset = NULL;
13253
13254 bfd_boolean
13255 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13256 {
13257   struct dwarf_section * section = &debug_displays [debug].section;
13258   Elf_Internal_Shdr * sec;
13259
13260   /* Locate the debug section.  */
13261   sec = find_section_in_set (section->uncompressed_name, section_subset);
13262   if (sec != NULL)
13263     section->name = section->uncompressed_name;
13264   else
13265     {
13266       sec = find_section_in_set (section->compressed_name, section_subset);
13267       if (sec != NULL)
13268         section->name = section->compressed_name;
13269     }
13270   if (sec == NULL)
13271     return FALSE;
13272
13273   /* If we're loading from a subset of sections, and we've loaded
13274      a section matching this name before, it's likely that it's a
13275      different one.  */
13276   if (section_subset != NULL)
13277     free_debug_section (debug);
13278
13279   return load_specific_debug_section (debug, sec, (FILE *) file);
13280 }
13281
13282 void
13283 free_debug_section (enum dwarf_section_display_enum debug)
13284 {
13285   struct dwarf_section * section = &debug_displays [debug].section;
13286
13287   if (section->start == NULL)
13288     return;
13289
13290   free ((char *) section->start);
13291   section->start = NULL;
13292   section->address = 0;
13293   section->size = 0;
13294 }
13295
13296 static bfd_boolean
13297 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13298 {
13299   char * name = SECTION_NAME (section);
13300   const char * print_name = printable_section_name (section);
13301   bfd_size_type length;
13302   bfd_boolean result = TRUE;
13303   int i;
13304
13305   length = section->sh_size;
13306   if (length == 0)
13307     {
13308       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13309       return TRUE;
13310     }
13311   if (section->sh_type == SHT_NOBITS)
13312     {
13313       /* There is no point in dumping the contents of a debugging section
13314          which has the NOBITS type - the bits in the file will be random.
13315          This can happen when a file containing a .eh_frame section is
13316          stripped with the --only-keep-debug command line option.  */
13317       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13318               print_name);
13319       return FALSE;
13320     }
13321
13322   if (const_strneq (name, ".gnu.linkonce.wi."))
13323     name = ".debug_info";
13324
13325   /* See if we know how to display the contents of this section.  */
13326   for (i = 0; i < max; i++)
13327     if (streq (debug_displays[i].section.uncompressed_name, name)
13328         || (i == line && const_strneq (name, ".debug_line."))
13329         || streq (debug_displays[i].section.compressed_name, name))
13330       {
13331         struct dwarf_section * sec = &debug_displays [i].section;
13332         int secondary = (section != find_section (name));
13333
13334         if (secondary)
13335           free_debug_section ((enum dwarf_section_display_enum) i);
13336
13337         if (i == line && const_strneq (name, ".debug_line."))
13338           sec->name = name;
13339         else if (streq (sec->uncompressed_name, name))
13340           sec->name = sec->uncompressed_name;
13341         else
13342           sec->name = sec->compressed_name;
13343         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13344                                          section, file))
13345           {
13346             /* If this debug section is part of a CU/TU set in a .dwp file,
13347                restrict load_debug_section to the sections in that set.  */
13348             section_subset = find_cu_tu_set (file, shndx);
13349
13350             result &= debug_displays[i].display (sec, file);
13351
13352             section_subset = NULL;
13353
13354             if (secondary || (i != info && i != abbrev))
13355               free_debug_section ((enum dwarf_section_display_enum) i);
13356           }
13357
13358         break;
13359       }
13360
13361   if (i == max)
13362     {
13363       printf (_("Unrecognized debug section: %s\n"), print_name);
13364       result = FALSE;
13365     }
13366
13367   return result;
13368 }
13369
13370 /* Set DUMP_SECTS for all sections where dumps were requested
13371    based on section name.  */
13372
13373 static void
13374 initialise_dumps_byname (void)
13375 {
13376   struct dump_list_entry * cur;
13377
13378   for (cur = dump_sects_byname; cur; cur = cur->next)
13379     {
13380       unsigned int i;
13381       bfd_boolean any = FALSE;
13382
13383       for (i = 0; i < elf_header.e_shnum; i++)
13384         if (streq (SECTION_NAME (section_headers + i), cur->name))
13385           {
13386             request_dump_bynumber (i, cur->type);
13387             any = TRUE;
13388           }
13389
13390       if (!any)
13391         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13392               cur->name);
13393     }
13394 }
13395
13396 static bfd_boolean
13397 process_section_contents (FILE * file)
13398 {
13399   Elf_Internal_Shdr * section;
13400   unsigned int i;
13401   bfd_boolean res = TRUE;
13402
13403   if (! do_dump)
13404     return TRUE;
13405
13406   initialise_dumps_byname ();
13407
13408   for (i = 0, section = section_headers;
13409        i < elf_header.e_shnum && i < num_dump_sects;
13410        i++, section++)
13411     {
13412 #ifdef SUPPORT_DISASSEMBLY
13413       if (dump_sects[i] & DISASS_DUMP)
13414         disassemble_section (section, file);
13415 #endif
13416       if (dump_sects[i] & HEX_DUMP)
13417         {
13418           if (! dump_section_as_bytes (section, file, FALSE))
13419             res = FALSE;
13420         }
13421
13422       if (dump_sects[i] & RELOC_DUMP)
13423         {
13424           if (! dump_section_as_bytes (section, file, TRUE))
13425             res = FALSE;
13426         }
13427
13428       if (dump_sects[i] & STRING_DUMP)
13429         {
13430           if (! dump_section_as_strings (section, file))
13431             res = FALSE;
13432         }
13433
13434       if (dump_sects[i] & DEBUG_DUMP)
13435         {
13436           if (! display_debug_section (i, section, file))
13437             res = FALSE;
13438         }
13439     }
13440
13441   /* Check to see if the user requested a
13442      dump of a section that does not exist.  */
13443   while (i < num_dump_sects)
13444     {
13445       if (dump_sects[i])
13446         {
13447           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13448           res = FALSE;
13449         }
13450       i++;
13451     }
13452
13453   return res;
13454 }
13455
13456 static void
13457 process_mips_fpe_exception (int mask)
13458 {
13459   if (mask)
13460     {
13461       bfd_boolean first = TRUE;
13462
13463       if (mask & OEX_FPU_INEX)
13464         fputs ("INEX", stdout), first = FALSE;
13465       if (mask & OEX_FPU_UFLO)
13466         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13467       if (mask & OEX_FPU_OFLO)
13468         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13469       if (mask & OEX_FPU_DIV0)
13470         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13471       if (mask & OEX_FPU_INVAL)
13472         printf ("%sINVAL", first ? "" : "|");
13473     }
13474   else
13475     fputs ("0", stdout);
13476 }
13477
13478 /* Display's the value of TAG at location P.  If TAG is
13479    greater than 0 it is assumed to be an unknown tag, and
13480    a message is printed to this effect.  Otherwise it is
13481    assumed that a message has already been printed.
13482
13483    If the bottom bit of TAG is set it assumed to have a
13484    string value, otherwise it is assumed to have an integer
13485    value.
13486
13487    Returns an updated P pointing to the first unread byte
13488    beyond the end of TAG's value.
13489
13490    Reads at or beyond END will not be made.  */
13491
13492 static unsigned char *
13493 display_tag_value (signed int tag,
13494                    unsigned char * p,
13495                    const unsigned char * const end)
13496 {
13497   unsigned long val;
13498
13499   if (tag > 0)
13500     printf ("  Tag_unknown_%d: ", tag);
13501
13502   if (p >= end)
13503     {
13504       warn (_("<corrupt tag>\n"));
13505     }
13506   else if (tag & 1)
13507     {
13508       /* PR 17531 file: 027-19978-0.004.  */
13509       size_t maxlen = (end - p) - 1;
13510
13511       putchar ('"');
13512       if (maxlen > 0)
13513         {
13514           print_symbol ((int) maxlen, (const char *) p);
13515           p += strnlen ((char *) p, maxlen) + 1;
13516         }
13517       else
13518         {
13519           printf (_("<corrupt string tag>"));
13520           p = (unsigned char *) end;
13521         }
13522       printf ("\"\n");
13523     }
13524   else
13525     {
13526       unsigned int len;
13527
13528       val = read_uleb128 (p, &len, end);
13529       p += len;
13530       printf ("%ld (0x%lx)\n", val, val);
13531     }
13532
13533   assert (p <= end);
13534   return p;
13535 }
13536
13537 /* ARC ABI attributes section.  */
13538
13539 static unsigned char *
13540 display_arc_attribute (unsigned char * p,
13541                        const unsigned char * const end)
13542 {
13543   unsigned int tag;
13544   unsigned int len;
13545   unsigned int val;
13546
13547   tag = read_uleb128 (p, &len, end);
13548   p += len;
13549
13550   switch (tag)
13551     {
13552     case Tag_ARC_PCS_config:
13553       val = read_uleb128 (p, &len, end);
13554       p += len;
13555       printf ("  Tag_ARC_PCS_config: ");
13556       switch (val)
13557         {
13558         case 0:
13559           printf (_("Absent/Non standard\n"));
13560           break;
13561         case 1:
13562           printf (_("Bare metal/mwdt\n"));
13563           break;
13564         case 2:
13565           printf (_("Bare metal/newlib\n"));
13566           break;
13567         case 3:
13568           printf (_("Linux/uclibc\n"));
13569           break;
13570         case 4:
13571           printf (_("Linux/glibc\n"));
13572           break;
13573         default:
13574           printf (_("Unknown\n"));
13575           break;
13576         }
13577       break;
13578
13579     case Tag_ARC_CPU_base:
13580       val = read_uleb128 (p, &len, end);
13581       p += len;
13582       printf ("  Tag_ARC_CPU_base: ");
13583       switch (val)
13584         {
13585         default:
13586         case TAG_CPU_NONE:
13587           printf (_("Absent\n"));
13588           break;
13589         case TAG_CPU_ARC6xx:
13590           printf ("ARC6xx\n");
13591           break;
13592         case TAG_CPU_ARC7xx:
13593           printf ("ARC7xx\n");
13594           break;
13595         case TAG_CPU_ARCEM:
13596           printf ("ARCEM\n");
13597           break;
13598         case TAG_CPU_ARCHS:
13599           printf ("ARCHS\n");
13600           break;
13601         }
13602       break;
13603
13604     case Tag_ARC_CPU_variation:
13605       val = read_uleb128 (p, &len, end);
13606       p += len;
13607       printf ("  Tag_ARC_CPU_variation: ");
13608       switch (val)
13609         {
13610         default:
13611           if (val > 0 && val < 16)
13612               printf ("Core%d\n", val);
13613           else
13614               printf ("Unknown\n");
13615           break;
13616
13617         case 0:
13618           printf (_("Absent\n"));
13619           break;
13620         }
13621       break;
13622
13623     case Tag_ARC_CPU_name:
13624       printf ("  Tag_ARC_CPU_name: ");
13625       p = display_tag_value (-1, p, end);
13626       break;
13627
13628     case Tag_ARC_ABI_rf16:
13629       val = read_uleb128 (p, &len, end);
13630       p += len;
13631       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13632       break;
13633
13634     case Tag_ARC_ABI_osver:
13635       val = read_uleb128 (p, &len, end);
13636       p += len;
13637       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13638       break;
13639
13640     case Tag_ARC_ABI_pic:
13641     case Tag_ARC_ABI_sda:
13642       val = read_uleb128 (p, &len, end);
13643       p += len;
13644       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13645               : "  Tag_ARC_ABI_pic: ");
13646       switch (val)
13647         {
13648         case 0:
13649           printf (_("Absent\n"));
13650           break;
13651         case 1:
13652           printf ("MWDT\n");
13653           break;
13654         case 2:
13655           printf ("GNU\n");
13656           break;
13657         default:
13658           printf (_("Unknown\n"));
13659           break;
13660         }
13661       break;
13662
13663     case Tag_ARC_ABI_tls:
13664       val = read_uleb128 (p, &len, end);
13665       p += len;
13666       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13667       break;
13668
13669     case Tag_ARC_ABI_enumsize:
13670       val = read_uleb128 (p, &len, end);
13671       p += len;
13672       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13673               _("smallest"));
13674       break;
13675
13676     case Tag_ARC_ABI_exceptions:
13677       val = read_uleb128 (p, &len, end);
13678       p += len;
13679       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13680               : _("default"));
13681       break;
13682
13683     case Tag_ARC_ABI_double_size:
13684       val = read_uleb128 (p, &len, end);
13685       p += len;
13686       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13687       break;
13688
13689     case Tag_ARC_ISA_config:
13690       printf ("  Tag_ARC_ISA_config: ");
13691       p = display_tag_value (-1, p, end);
13692       break;
13693
13694     case Tag_ARC_ISA_apex:
13695       printf ("  Tag_ARC_ISA_apex: ");
13696       p = display_tag_value (-1, p, end);
13697       break;
13698
13699     case Tag_ARC_ISA_mpy_option:
13700       val = read_uleb128 (p, &len, end);
13701       p += len;
13702       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13703       break;
13704
13705     default:
13706       return display_tag_value (tag & 1, p, end);
13707     }
13708
13709   return p;
13710 }
13711
13712 /* ARM EABI attributes section.  */
13713 typedef struct
13714 {
13715   unsigned int tag;
13716   const char * name;
13717   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13718   unsigned int type;
13719   const char ** table;
13720 } arm_attr_public_tag;
13721
13722 static const char * arm_attr_tag_CPU_arch[] =
13723   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13724    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13725    "v8-M.mainline"};
13726 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13727 static const char * arm_attr_tag_THUMB_ISA_use[] =
13728   {"No", "Thumb-1", "Thumb-2", "Yes"};
13729 static const char * arm_attr_tag_FP_arch[] =
13730   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13731    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13732 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13733 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13734   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13735    "NEON for ARMv8.1"};
13736 static const char * arm_attr_tag_PCS_config[] =
13737   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13738    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13739 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13740   {"V6", "SB", "TLS", "Unused"};
13741 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13742   {"Absolute", "PC-relative", "SB-relative", "None"};
13743 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13744   {"Absolute", "PC-relative", "None"};
13745 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13746   {"None", "direct", "GOT-indirect"};
13747 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13748   {"None", "??? 1", "2", "??? 3", "4"};
13749 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13750 static const char * arm_attr_tag_ABI_FP_denormal[] =
13751   {"Unused", "Needed", "Sign only"};
13752 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13753 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13754 static const char * arm_attr_tag_ABI_FP_number_model[] =
13755   {"Unused", "Finite", "RTABI", "IEEE 754"};
13756 static const char * arm_attr_tag_ABI_enum_size[] =
13757   {"Unused", "small", "int", "forced to int"};
13758 static const char * arm_attr_tag_ABI_HardFP_use[] =
13759   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13760 static const char * arm_attr_tag_ABI_VFP_args[] =
13761   {"AAPCS", "VFP registers", "custom", "compatible"};
13762 static const char * arm_attr_tag_ABI_WMMX_args[] =
13763   {"AAPCS", "WMMX registers", "custom"};
13764 static const char * arm_attr_tag_ABI_optimization_goals[] =
13765   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13766     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13767 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13768   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13769     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13770 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13771 static const char * arm_attr_tag_FP_HP_extension[] =
13772   {"Not Allowed", "Allowed"};
13773 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13774   {"None", "IEEE 754", "Alternative Format"};
13775 static const char * arm_attr_tag_DSP_extension[] =
13776   {"Follow architecture", "Allowed"};
13777 static const char * arm_attr_tag_MPextension_use[] =
13778   {"Not Allowed", "Allowed"};
13779 static const char * arm_attr_tag_DIV_use[] =
13780   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13781     "Allowed in v7-A with integer division extension"};
13782 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13783 static const char * arm_attr_tag_Virtualization_use[] =
13784   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13785     "TrustZone and Virtualization Extensions"};
13786 static const char * arm_attr_tag_MPextension_use_legacy[] =
13787   {"Not Allowed", "Allowed"};
13788
13789 #define LOOKUP(id, name) \
13790   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13791 static arm_attr_public_tag arm_attr_public_tags[] =
13792 {
13793   {4, "CPU_raw_name", 1, NULL},
13794   {5, "CPU_name", 1, NULL},
13795   LOOKUP(6, CPU_arch),
13796   {7, "CPU_arch_profile", 0, NULL},
13797   LOOKUP(8, ARM_ISA_use),
13798   LOOKUP(9, THUMB_ISA_use),
13799   LOOKUP(10, FP_arch),
13800   LOOKUP(11, WMMX_arch),
13801   LOOKUP(12, Advanced_SIMD_arch),
13802   LOOKUP(13, PCS_config),
13803   LOOKUP(14, ABI_PCS_R9_use),
13804   LOOKUP(15, ABI_PCS_RW_data),
13805   LOOKUP(16, ABI_PCS_RO_data),
13806   LOOKUP(17, ABI_PCS_GOT_use),
13807   LOOKUP(18, ABI_PCS_wchar_t),
13808   LOOKUP(19, ABI_FP_rounding),
13809   LOOKUP(20, ABI_FP_denormal),
13810   LOOKUP(21, ABI_FP_exceptions),
13811   LOOKUP(22, ABI_FP_user_exceptions),
13812   LOOKUP(23, ABI_FP_number_model),
13813   {24, "ABI_align_needed", 0, NULL},
13814   {25, "ABI_align_preserved", 0, NULL},
13815   LOOKUP(26, ABI_enum_size),
13816   LOOKUP(27, ABI_HardFP_use),
13817   LOOKUP(28, ABI_VFP_args),
13818   LOOKUP(29, ABI_WMMX_args),
13819   LOOKUP(30, ABI_optimization_goals),
13820   LOOKUP(31, ABI_FP_optimization_goals),
13821   {32, "compatibility", 0, NULL},
13822   LOOKUP(34, CPU_unaligned_access),
13823   LOOKUP(36, FP_HP_extension),
13824   LOOKUP(38, ABI_FP_16bit_format),
13825   LOOKUP(42, MPextension_use),
13826   LOOKUP(44, DIV_use),
13827   LOOKUP(46, DSP_extension),
13828   {64, "nodefaults", 0, NULL},
13829   {65, "also_compatible_with", 0, NULL},
13830   LOOKUP(66, T2EE_use),
13831   {67, "conformance", 1, NULL},
13832   LOOKUP(68, Virtualization_use),
13833   LOOKUP(70, MPextension_use_legacy)
13834 };
13835 #undef LOOKUP
13836
13837 static unsigned char *
13838 display_arm_attribute (unsigned char * p,
13839                        const unsigned char * const end)
13840 {
13841   unsigned int tag;
13842   unsigned int len;
13843   unsigned int val;
13844   arm_attr_public_tag * attr;
13845   unsigned i;
13846   unsigned int type;
13847
13848   tag = read_uleb128 (p, &len, end);
13849   p += len;
13850   attr = NULL;
13851   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13852     {
13853       if (arm_attr_public_tags[i].tag == tag)
13854         {
13855           attr = &arm_attr_public_tags[i];
13856           break;
13857         }
13858     }
13859
13860   if (attr)
13861     {
13862       printf ("  Tag_%s: ", attr->name);
13863       switch (attr->type)
13864         {
13865         case 0:
13866           switch (tag)
13867             {
13868             case 7: /* Tag_CPU_arch_profile.  */
13869               val = read_uleb128 (p, &len, end);
13870               p += len;
13871               switch (val)
13872                 {
13873                 case 0: printf (_("None\n")); break;
13874                 case 'A': printf (_("Application\n")); break;
13875                 case 'R': printf (_("Realtime\n")); break;
13876                 case 'M': printf (_("Microcontroller\n")); break;
13877                 case 'S': printf (_("Application or Realtime\n")); break;
13878                 default: printf ("??? (%d)\n", val); break;
13879                 }
13880               break;
13881
13882             case 24: /* Tag_align_needed.  */
13883               val = read_uleb128 (p, &len, end);
13884               p += len;
13885               switch (val)
13886                 {
13887                 case 0: printf (_("None\n")); break;
13888                 case 1: printf (_("8-byte\n")); break;
13889                 case 2: printf (_("4-byte\n")); break;
13890                 case 3: printf ("??? 3\n"); break;
13891                 default:
13892                   if (val <= 12)
13893                     printf (_("8-byte and up to %d-byte extended\n"),
13894                             1 << val);
13895                   else
13896                     printf ("??? (%d)\n", val);
13897                   break;
13898                 }
13899               break;
13900
13901             case 25: /* Tag_align_preserved.  */
13902               val = read_uleb128 (p, &len, end);
13903               p += len;
13904               switch (val)
13905                 {
13906                 case 0: printf (_("None\n")); break;
13907                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13908                 case 2: printf (_("8-byte\n")); break;
13909                 case 3: printf ("??? 3\n"); break;
13910                 default:
13911                   if (val <= 12)
13912                     printf (_("8-byte and up to %d-byte extended\n"),
13913                             1 << val);
13914                   else
13915                     printf ("??? (%d)\n", val);
13916                   break;
13917                 }
13918               break;
13919
13920             case 32: /* Tag_compatibility.  */
13921               {
13922                 val = read_uleb128 (p, &len, end);
13923                 p += len;
13924                 printf (_("flag = %d, vendor = "), val);
13925                 if (p < end - 1)
13926                   {
13927                     size_t maxlen = (end - p) - 1;
13928
13929                     print_symbol ((int) maxlen, (const char *) p);
13930                     p += strnlen ((char *) p, maxlen) + 1;
13931                   }
13932                 else
13933                   {
13934                     printf (_("<corrupt>"));
13935                     p = (unsigned char *) end;
13936                   }
13937                 putchar ('\n');
13938               }
13939               break;
13940
13941             case 64: /* Tag_nodefaults.  */
13942               /* PR 17531: file: 001-505008-0.01.  */
13943               if (p < end)
13944                 p++;
13945               printf (_("True\n"));
13946               break;
13947
13948             case 65: /* Tag_also_compatible_with.  */
13949               val = read_uleb128 (p, &len, end);
13950               p += len;
13951               if (val == 6 /* Tag_CPU_arch.  */)
13952                 {
13953                   val = read_uleb128 (p, &len, end);
13954                   p += len;
13955                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13956                     printf ("??? (%d)\n", val);
13957                   else
13958                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13959                 }
13960               else
13961                 printf ("???\n");
13962               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13963                 ;
13964               break;
13965
13966             default:
13967               printf (_("<unknown: %d>\n"), tag);
13968               break;
13969             }
13970           return p;
13971
13972         case 1:
13973           return display_tag_value (-1, p, end);
13974         case 2:
13975           return display_tag_value (0, p, end);
13976
13977         default:
13978           assert (attr->type & 0x80);
13979           val = read_uleb128 (p, &len, end);
13980           p += len;
13981           type = attr->type & 0x7f;
13982           if (val >= type)
13983             printf ("??? (%d)\n", val);
13984           else
13985             printf ("%s\n", attr->table[val]);
13986           return p;
13987         }
13988     }
13989
13990   return display_tag_value (tag, p, end);
13991 }
13992
13993 static unsigned char *
13994 display_gnu_attribute (unsigned char * p,
13995                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13996                        const unsigned char * const end)
13997 {
13998   int tag;
13999   unsigned int len;
14000   unsigned int val;
14001
14002   tag = read_uleb128 (p, &len, end);
14003   p += len;
14004
14005   /* Tag_compatibility is the only generic GNU attribute defined at
14006      present.  */
14007   if (tag == 32)
14008     {
14009       val = read_uleb128 (p, &len, end);
14010       p += len;
14011
14012       printf (_("flag = %d, vendor = "), val);
14013       if (p == end)
14014         {
14015           printf (_("<corrupt>\n"));
14016           warn (_("corrupt vendor attribute\n"));
14017         }
14018       else
14019         {
14020           if (p < end - 1)
14021             {
14022               size_t maxlen = (end - p) - 1;
14023
14024               print_symbol ((int) maxlen, (const char *) p);
14025               p += strnlen ((char *) p, maxlen) + 1;
14026             }
14027           else
14028             {
14029               printf (_("<corrupt>"));
14030               p = (unsigned char *) end;
14031             }
14032           putchar ('\n');
14033         }
14034       return p;
14035     }
14036
14037   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14038     return display_proc_gnu_attribute (p, tag, end);
14039
14040   return display_tag_value (tag, p, end);
14041 }
14042
14043 static unsigned char *
14044 display_power_gnu_attribute (unsigned char * p,
14045                              unsigned int tag,
14046                              const unsigned char * const end)
14047 {
14048   unsigned int len;
14049   unsigned int val;
14050
14051   if (tag == Tag_GNU_Power_ABI_FP)
14052     {
14053       val = read_uleb128 (p, &len, end);
14054       p += len;
14055       printf ("  Tag_GNU_Power_ABI_FP: ");
14056       if (len == 0)
14057         {
14058           printf (_("<corrupt>\n"));
14059           return p;
14060         }
14061
14062       if (val > 15)
14063         printf ("(%#x), ", val);
14064
14065       switch (val & 3)
14066         {
14067         case 0:
14068           printf (_("unspecified hard/soft float, "));
14069           break;
14070         case 1:
14071           printf (_("hard float, "));
14072           break;
14073         case 2:
14074           printf (_("soft float, "));
14075           break;
14076         case 3:
14077           printf (_("single-precision hard float, "));
14078           break;
14079         }
14080
14081       switch (val & 0xC)
14082         {
14083         case 0:
14084           printf (_("unspecified long double\n"));
14085           break;
14086         case 4:
14087           printf (_("128-bit IBM long double\n"));
14088           break;
14089         case 8:
14090           printf (_("64-bit long double\n"));
14091           break;
14092         case 12:
14093           printf (_("128-bit IEEE long double\n"));
14094           break;
14095         }
14096       return p;
14097     }
14098
14099   if (tag == Tag_GNU_Power_ABI_Vector)
14100     {
14101       val = read_uleb128 (p, &len, end);
14102       p += len;
14103       printf ("  Tag_GNU_Power_ABI_Vector: ");
14104       if (len == 0)
14105         {
14106           printf (_("<corrupt>\n"));
14107           return p;
14108         }
14109
14110       if (val > 3)
14111         printf ("(%#x), ", val);
14112
14113       switch (val & 3)
14114         {
14115         case 0:
14116           printf (_("unspecified\n"));
14117           break;
14118         case 1:
14119           printf (_("generic\n"));
14120           break;
14121         case 2:
14122           printf ("AltiVec\n");
14123           break;
14124         case 3:
14125           printf ("SPE\n");
14126           break;
14127         }
14128       return p;
14129     }
14130
14131   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14132     {
14133       val = read_uleb128 (p, &len, end);
14134       p += len;
14135       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14136       if (len == 0)
14137         {
14138           printf (_("<corrupt>\n"));
14139           return p;
14140         }
14141
14142       if (val > 2)
14143         printf ("(%#x), ", val);
14144
14145       switch (val & 3)
14146         {
14147         case 0:
14148           printf (_("unspecified\n"));
14149           break;
14150         case 1:
14151           printf ("r3/r4\n");
14152           break;
14153         case 2:
14154           printf (_("memory\n"));
14155           break;
14156         case 3:
14157           printf ("???\n");
14158           break;
14159         }
14160       return p;
14161     }
14162
14163   return display_tag_value (tag & 1, p, end);
14164 }
14165
14166 static unsigned char *
14167 display_s390_gnu_attribute (unsigned char * p,
14168                             unsigned int tag,
14169                             const unsigned char * const end)
14170 {
14171   unsigned int len;
14172   int val;
14173
14174   if (tag == Tag_GNU_S390_ABI_Vector)
14175     {
14176       val = read_uleb128 (p, &len, end);
14177       p += len;
14178       printf ("  Tag_GNU_S390_ABI_Vector: ");
14179
14180       switch (val)
14181         {
14182         case 0:
14183           printf (_("any\n"));
14184           break;
14185         case 1:
14186           printf (_("software\n"));
14187           break;
14188         case 2:
14189           printf (_("hardware\n"));
14190           break;
14191         default:
14192           printf ("??? (%d)\n", val);
14193           break;
14194         }
14195       return p;
14196    }
14197
14198   return display_tag_value (tag & 1, p, end);
14199 }
14200
14201 static void
14202 display_sparc_hwcaps (unsigned int mask)
14203 {
14204   if (mask)
14205     {
14206       bfd_boolean first = TRUE;
14207
14208       if (mask & ELF_SPARC_HWCAP_MUL32)
14209         fputs ("mul32", stdout), first = FALSE;
14210       if (mask & ELF_SPARC_HWCAP_DIV32)
14211         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14212       if (mask & ELF_SPARC_HWCAP_FSMULD)
14213         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14214       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14215         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14216       if (mask & ELF_SPARC_HWCAP_POPC)
14217         printf ("%spopc", first ? "" : "|"), first = FALSE;
14218       if (mask & ELF_SPARC_HWCAP_VIS)
14219         printf ("%svis", first ? "" : "|"), first = FALSE;
14220       if (mask & ELF_SPARC_HWCAP_VIS2)
14221         printf ("%svis2", first ? "" : "|"), first = FALSE;
14222       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14223         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14224       if (mask & ELF_SPARC_HWCAP_FMAF)
14225         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14226       if (mask & ELF_SPARC_HWCAP_VIS3)
14227         printf ("%svis3", first ? "" : "|"), first = FALSE;
14228       if (mask & ELF_SPARC_HWCAP_HPC)
14229         printf ("%shpc", first ? "" : "|"), first = FALSE;
14230       if (mask & ELF_SPARC_HWCAP_RANDOM)
14231         printf ("%srandom", first ? "" : "|"), first = FALSE;
14232       if (mask & ELF_SPARC_HWCAP_TRANS)
14233         printf ("%strans", first ? "" : "|"), first = FALSE;
14234       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14235         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14236       if (mask & ELF_SPARC_HWCAP_IMA)
14237         printf ("%sima", first ? "" : "|"), first = FALSE;
14238       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14239         printf ("%scspare", first ? "" : "|"), first = FALSE;
14240     }
14241   else
14242     fputc ('0', stdout);
14243   fputc ('\n', stdout);
14244 }
14245
14246 static void
14247 display_sparc_hwcaps2 (unsigned int mask)
14248 {
14249   if (mask)
14250     {
14251       bfd_boolean first = TRUE;
14252
14253       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14254         fputs ("fjathplus", stdout), first = FALSE;
14255       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14256         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14257       if (mask & ELF_SPARC_HWCAP2_ADP)
14258         printf ("%sadp", first ? "" : "|"), first = FALSE;
14259       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14260         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14261       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14262         printf ("%smwait", first ? "" : "|"), first = FALSE;
14263       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14264         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14265       if (mask & ELF_SPARC_HWCAP2_XMONT)
14266         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14267       if (mask & ELF_SPARC_HWCAP2_NSEC)
14268         printf ("%snsec", first ? "" : "|"), first = FALSE;
14269       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14270         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14271       if (mask & ELF_SPARC_HWCAP2_FJDES)
14272         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14273       if (mask & ELF_SPARC_HWCAP2_FJAES)
14274         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14275     }
14276   else
14277     fputc ('0', stdout);
14278   fputc ('\n', stdout);
14279 }
14280
14281 static unsigned char *
14282 display_sparc_gnu_attribute (unsigned char * p,
14283                              unsigned int tag,
14284                              const unsigned char * const end)
14285 {
14286   unsigned int len;
14287   int val;
14288
14289   if (tag == Tag_GNU_Sparc_HWCAPS)
14290     {
14291       val = read_uleb128 (p, &len, end);
14292       p += len;
14293       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14294       display_sparc_hwcaps (val);
14295       return p;
14296     }
14297   if (tag == Tag_GNU_Sparc_HWCAPS2)
14298     {
14299       val = read_uleb128 (p, &len, end);
14300       p += len;
14301       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14302       display_sparc_hwcaps2 (val);
14303       return p;
14304     }
14305
14306   return display_tag_value (tag, p, end);
14307 }
14308
14309 static void
14310 print_mips_fp_abi_value (unsigned int val)
14311 {
14312   switch (val)
14313     {
14314     case Val_GNU_MIPS_ABI_FP_ANY:
14315       printf (_("Hard or soft float\n"));
14316       break;
14317     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14318       printf (_("Hard float (double precision)\n"));
14319       break;
14320     case Val_GNU_MIPS_ABI_FP_SINGLE:
14321       printf (_("Hard float (single precision)\n"));
14322       break;
14323     case Val_GNU_MIPS_ABI_FP_SOFT:
14324       printf (_("Soft float\n"));
14325       break;
14326     case Val_GNU_MIPS_ABI_FP_OLD_64:
14327       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14328       break;
14329     case Val_GNU_MIPS_ABI_FP_XX:
14330       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14331       break;
14332     case Val_GNU_MIPS_ABI_FP_64:
14333       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14334       break;
14335     case Val_GNU_MIPS_ABI_FP_64A:
14336       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14337       break;
14338     case Val_GNU_MIPS_ABI_FP_NAN2008:
14339       printf (_("NaN 2008 compatibility\n"));
14340       break;
14341     default:
14342       printf ("??? (%d)\n", val);
14343       break;
14344     }
14345 }
14346
14347 static unsigned char *
14348 display_mips_gnu_attribute (unsigned char * p,
14349                             unsigned int tag,
14350                             const unsigned char * const end)
14351 {
14352   if (tag == Tag_GNU_MIPS_ABI_FP)
14353     {
14354       unsigned int len;
14355       unsigned int val;
14356
14357       val = read_uleb128 (p, &len, end);
14358       p += len;
14359       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14360
14361       print_mips_fp_abi_value (val);
14362
14363       return p;
14364    }
14365
14366   if (tag == Tag_GNU_MIPS_ABI_MSA)
14367     {
14368       unsigned int len;
14369       unsigned int val;
14370
14371       val = read_uleb128 (p, &len, end);
14372       p += len;
14373       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14374
14375       switch (val)
14376         {
14377         case Val_GNU_MIPS_ABI_MSA_ANY:
14378           printf (_("Any MSA or not\n"));
14379           break;
14380         case Val_GNU_MIPS_ABI_MSA_128:
14381           printf (_("128-bit MSA\n"));
14382           break;
14383         default:
14384           printf ("??? (%d)\n", val);
14385           break;
14386         }
14387       return p;
14388     }
14389
14390   return display_tag_value (tag & 1, p, end);
14391 }
14392
14393 static unsigned char *
14394 display_tic6x_attribute (unsigned char * p,
14395                          const unsigned char * const end)
14396 {
14397   unsigned int tag;
14398   unsigned int len;
14399   int val;
14400
14401   tag = read_uleb128 (p, &len, end);
14402   p += len;
14403
14404   switch (tag)
14405     {
14406     case Tag_ISA:
14407       val = read_uleb128 (p, &len, end);
14408       p += len;
14409       printf ("  Tag_ISA: ");
14410
14411       switch (val)
14412         {
14413         case C6XABI_Tag_ISA_none:
14414           printf (_("None\n"));
14415           break;
14416         case C6XABI_Tag_ISA_C62X:
14417           printf ("C62x\n");
14418           break;
14419         case C6XABI_Tag_ISA_C67X:
14420           printf ("C67x\n");
14421           break;
14422         case C6XABI_Tag_ISA_C67XP:
14423           printf ("C67x+\n");
14424           break;
14425         case C6XABI_Tag_ISA_C64X:
14426           printf ("C64x\n");
14427           break;
14428         case C6XABI_Tag_ISA_C64XP:
14429           printf ("C64x+\n");
14430           break;
14431         case C6XABI_Tag_ISA_C674X:
14432           printf ("C674x\n");
14433           break;
14434         default:
14435           printf ("??? (%d)\n", val);
14436           break;
14437         }
14438       return p;
14439
14440     case Tag_ABI_wchar_t:
14441       val = read_uleb128 (p, &len, end);
14442       p += len;
14443       printf ("  Tag_ABI_wchar_t: ");
14444       switch (val)
14445         {
14446         case 0:
14447           printf (_("Not used\n"));
14448           break;
14449         case 1:
14450           printf (_("2 bytes\n"));
14451           break;
14452         case 2:
14453           printf (_("4 bytes\n"));
14454           break;
14455         default:
14456           printf ("??? (%d)\n", val);
14457           break;
14458         }
14459       return p;
14460
14461     case Tag_ABI_stack_align_needed:
14462       val = read_uleb128 (p, &len, end);
14463       p += len;
14464       printf ("  Tag_ABI_stack_align_needed: ");
14465       switch (val)
14466         {
14467         case 0:
14468           printf (_("8-byte\n"));
14469           break;
14470         case 1:
14471           printf (_("16-byte\n"));
14472           break;
14473         default:
14474           printf ("??? (%d)\n", val);
14475           break;
14476         }
14477       return p;
14478
14479     case Tag_ABI_stack_align_preserved:
14480       val = read_uleb128 (p, &len, end);
14481       p += len;
14482       printf ("  Tag_ABI_stack_align_preserved: ");
14483       switch (val)
14484         {
14485         case 0:
14486           printf (_("8-byte\n"));
14487           break;
14488         case 1:
14489           printf (_("16-byte\n"));
14490           break;
14491         default:
14492           printf ("??? (%d)\n", val);
14493           break;
14494         }
14495       return p;
14496
14497     case Tag_ABI_DSBT:
14498       val = read_uleb128 (p, &len, end);
14499       p += len;
14500       printf ("  Tag_ABI_DSBT: ");
14501       switch (val)
14502         {
14503         case 0:
14504           printf (_("DSBT addressing not used\n"));
14505           break;
14506         case 1:
14507           printf (_("DSBT addressing used\n"));
14508           break;
14509         default:
14510           printf ("??? (%d)\n", val);
14511           break;
14512         }
14513       return p;
14514
14515     case Tag_ABI_PID:
14516       val = read_uleb128 (p, &len, end);
14517       p += len;
14518       printf ("  Tag_ABI_PID: ");
14519       switch (val)
14520         {
14521         case 0:
14522           printf (_("Data addressing position-dependent\n"));
14523           break;
14524         case 1:
14525           printf (_("Data addressing position-independent, GOT near DP\n"));
14526           break;
14527         case 2:
14528           printf (_("Data addressing position-independent, GOT far from DP\n"));
14529           break;
14530         default:
14531           printf ("??? (%d)\n", val);
14532           break;
14533         }
14534       return p;
14535
14536     case Tag_ABI_PIC:
14537       val = read_uleb128 (p, &len, end);
14538       p += len;
14539       printf ("  Tag_ABI_PIC: ");
14540       switch (val)
14541         {
14542         case 0:
14543           printf (_("Code addressing position-dependent\n"));
14544           break;
14545         case 1:
14546           printf (_("Code addressing position-independent\n"));
14547           break;
14548         default:
14549           printf ("??? (%d)\n", val);
14550           break;
14551         }
14552       return p;
14553
14554     case Tag_ABI_array_object_alignment:
14555       val = read_uleb128 (p, &len, end);
14556       p += len;
14557       printf ("  Tag_ABI_array_object_alignment: ");
14558       switch (val)
14559         {
14560         case 0:
14561           printf (_("8-byte\n"));
14562           break;
14563         case 1:
14564           printf (_("4-byte\n"));
14565           break;
14566         case 2:
14567           printf (_("16-byte\n"));
14568           break;
14569         default:
14570           printf ("??? (%d)\n", val);
14571           break;
14572         }
14573       return p;
14574
14575     case Tag_ABI_array_object_align_expected:
14576       val = read_uleb128 (p, &len, end);
14577       p += len;
14578       printf ("  Tag_ABI_array_object_align_expected: ");
14579       switch (val)
14580         {
14581         case 0:
14582           printf (_("8-byte\n"));
14583           break;
14584         case 1:
14585           printf (_("4-byte\n"));
14586           break;
14587         case 2:
14588           printf (_("16-byte\n"));
14589           break;
14590         default:
14591           printf ("??? (%d)\n", val);
14592           break;
14593         }
14594       return p;
14595
14596     case Tag_ABI_compatibility:
14597       {
14598         val = read_uleb128 (p, &len, end);
14599         p += len;
14600         printf ("  Tag_ABI_compatibility: ");
14601         printf (_("flag = %d, vendor = "), val);
14602         if (p < end - 1)
14603           {
14604             size_t maxlen = (end - p) - 1;
14605
14606             print_symbol ((int) maxlen, (const char *) p);
14607             p += strnlen ((char *) p, maxlen) + 1;
14608           }
14609         else
14610           {
14611             printf (_("<corrupt>"));
14612             p = (unsigned char *) end;
14613           }
14614         putchar ('\n');
14615         return p;
14616       }
14617
14618     case Tag_ABI_conformance:
14619       {
14620         printf ("  Tag_ABI_conformance: \"");
14621         if (p < end - 1)
14622           {
14623             size_t maxlen = (end - p) - 1;
14624
14625             print_symbol ((int) maxlen, (const char *) p);
14626             p += strnlen ((char *) p, maxlen) + 1;
14627           }
14628         else
14629           {
14630             printf (_("<corrupt>"));
14631             p = (unsigned char *) end;
14632           }
14633         printf ("\"\n");
14634         return p;
14635       }
14636     }
14637
14638   return display_tag_value (tag, p, end);
14639 }
14640
14641 static void
14642 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14643 {
14644   unsigned long addr = 0;
14645   size_t bytes = end - p;
14646
14647   assert (end > p);
14648   while (bytes)
14649     {
14650       int j;
14651       int k;
14652       int lbytes = (bytes > 16 ? 16 : bytes);
14653
14654       printf ("  0x%8.8lx ", addr);
14655
14656       for (j = 0; j < 16; j++)
14657         {
14658           if (j < lbytes)
14659             printf ("%2.2x", p[j]);
14660           else
14661             printf ("  ");
14662
14663           if ((j & 3) == 3)
14664             printf (" ");
14665         }
14666
14667       for (j = 0; j < lbytes; j++)
14668         {
14669           k = p[j];
14670           if (k >= ' ' && k < 0x7f)
14671             printf ("%c", k);
14672           else
14673             printf (".");
14674         }
14675
14676       putchar ('\n');
14677
14678       p  += lbytes;
14679       bytes -= lbytes;
14680       addr += lbytes;
14681     }
14682
14683   putchar ('\n');
14684 }
14685
14686 static unsigned char *
14687 display_msp430x_attribute (unsigned char * p,
14688                            const unsigned char * const end)
14689 {
14690   unsigned int len;
14691   unsigned int val;
14692   unsigned int tag;
14693
14694   tag = read_uleb128 (p, & len, end);
14695   p += len;
14696
14697   switch (tag)
14698     {
14699     case OFBA_MSPABI_Tag_ISA:
14700       val = read_uleb128 (p, &len, end);
14701       p += len;
14702       printf ("  Tag_ISA: ");
14703       switch (val)
14704         {
14705         case 0: printf (_("None\n")); break;
14706         case 1: printf (_("MSP430\n")); break;
14707         case 2: printf (_("MSP430X\n")); break;
14708         default: printf ("??? (%d)\n", val); break;
14709         }
14710       break;
14711
14712     case OFBA_MSPABI_Tag_Code_Model:
14713       val = read_uleb128 (p, &len, end);
14714       p += len;
14715       printf ("  Tag_Code_Model: ");
14716       switch (val)
14717         {
14718         case 0: printf (_("None\n")); break;
14719         case 1: printf (_("Small\n")); break;
14720         case 2: printf (_("Large\n")); break;
14721         default: printf ("??? (%d)\n", val); break;
14722         }
14723       break;
14724
14725     case OFBA_MSPABI_Tag_Data_Model:
14726       val = read_uleb128 (p, &len, end);
14727       p += len;
14728       printf ("  Tag_Data_Model: ");
14729       switch (val)
14730         {
14731         case 0: printf (_("None\n")); break;
14732         case 1: printf (_("Small\n")); break;
14733         case 2: printf (_("Large\n")); break;
14734         case 3: printf (_("Restricted Large\n")); break;
14735         default: printf ("??? (%d)\n", val); break;
14736         }
14737       break;
14738
14739     default:
14740       printf (_("  <unknown tag %d>: "), tag);
14741
14742       if (tag & 1)
14743         {
14744           putchar ('"');
14745           if (p < end - 1)
14746             {
14747               size_t maxlen = (end - p) - 1;
14748
14749               print_symbol ((int) maxlen, (const char *) p);
14750               p += strnlen ((char *) p, maxlen) + 1;
14751             }
14752           else
14753             {
14754               printf (_("<corrupt>"));
14755               p = (unsigned char *) end;
14756             }
14757           printf ("\"\n");
14758         }
14759       else
14760         {
14761           val = read_uleb128 (p, &len, end);
14762           p += len;
14763           printf ("%d (0x%x)\n", val, val);
14764         }
14765       break;
14766    }
14767
14768   assert (p <= end);
14769   return p;
14770 }
14771
14772 static bfd_boolean
14773 process_attributes (FILE * file,
14774                     const char * public_name,
14775                     unsigned int proc_type,
14776                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14777                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14778 {
14779   Elf_Internal_Shdr * sect;
14780   unsigned i;
14781   bfd_boolean res = TRUE;
14782
14783   /* Find the section header so that we get the size.  */
14784   for (i = 0, sect = section_headers;
14785        i < elf_header.e_shnum;
14786        i++, sect++)
14787     {
14788       unsigned char * contents;
14789       unsigned char * p;
14790
14791       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14792         continue;
14793
14794       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14795                                              sect->sh_size, _("attributes"));
14796       if (contents == NULL)
14797         {
14798           res = FALSE;
14799           continue;
14800         }
14801
14802       p = contents;
14803       /* The first character is the version of the attributes.
14804          Currently only version 1, (aka 'A') is recognised here.  */
14805       if (*p != 'A')
14806         {
14807           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14808           res = FALSE;
14809         }
14810       else
14811         {
14812           bfd_vma section_len;
14813
14814           section_len = sect->sh_size - 1;
14815           p++;
14816
14817           while (section_len > 0)
14818             {
14819               bfd_vma attr_len;
14820               unsigned int namelen;
14821               bfd_boolean public_section;
14822               bfd_boolean gnu_section;
14823
14824               if (section_len <= 4)
14825                 {
14826                   error (_("Tag section ends prematurely\n"));
14827                   res = FALSE;
14828                   break;
14829                 }
14830               attr_len = byte_get (p, 4);
14831               p += 4;
14832
14833               if (attr_len > section_len)
14834                 {
14835                   error (_("Bad attribute length (%u > %u)\n"),
14836                           (unsigned) attr_len, (unsigned) section_len);
14837                   attr_len = section_len;
14838                   res = FALSE;
14839                 }
14840               /* PR 17531: file: 001-101425-0.004  */
14841               else if (attr_len < 5)
14842                 {
14843                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14844                   res = FALSE;
14845                   break;
14846                 }
14847
14848               section_len -= attr_len;
14849               attr_len -= 4;
14850
14851               namelen = strnlen ((char *) p, attr_len) + 1;
14852               if (namelen == 0 || namelen >= attr_len)
14853                 {
14854                   error (_("Corrupt attribute section name\n"));
14855                   res = FALSE;
14856                   break;
14857                 }
14858
14859               printf (_("Attribute Section: "));
14860               print_symbol (INT_MAX, (const char *) p);
14861               putchar ('\n');
14862
14863               if (public_name && streq ((char *) p, public_name))
14864                 public_section = TRUE;
14865               else
14866                 public_section = FALSE;
14867
14868               if (streq ((char *) p, "gnu"))
14869                 gnu_section = TRUE;
14870               else
14871                 gnu_section = FALSE;
14872
14873               p += namelen;
14874               attr_len -= namelen;
14875
14876               while (attr_len > 0 && p < contents + sect->sh_size)
14877                 {
14878                   int tag;
14879                   int val;
14880                   bfd_vma size;
14881                   unsigned char * end;
14882
14883                   /* PR binutils/17531: Safe handling of corrupt files.  */
14884                   if (attr_len < 6)
14885                     {
14886                       error (_("Unused bytes at end of section\n"));
14887                       res = FALSE;
14888                       section_len = 0;
14889                       break;
14890                     }
14891
14892                   tag = *(p++);
14893                   size = byte_get (p, 4);
14894                   if (size > attr_len)
14895                     {
14896                       error (_("Bad subsection length (%u > %u)\n"),
14897                               (unsigned) size, (unsigned) attr_len);
14898                       res = FALSE;
14899                       size = attr_len;
14900                     }
14901                   /* PR binutils/17531: Safe handling of corrupt files.  */
14902                   if (size < 6)
14903                     {
14904                       error (_("Bad subsection length (%u < 6)\n"),
14905                               (unsigned) size);
14906                       res = FALSE;
14907                       section_len = 0;
14908                       break;
14909                     }
14910
14911                   attr_len -= size;
14912                   end = p + size - 1;
14913                   assert (end <= contents + sect->sh_size);
14914                   p += 4;
14915
14916                   switch (tag)
14917                     {
14918                     case 1:
14919                       printf (_("File Attributes\n"));
14920                       break;
14921                     case 2:
14922                       printf (_("Section Attributes:"));
14923                       goto do_numlist;
14924                     case 3:
14925                       printf (_("Symbol Attributes:"));
14926                       /* Fall through.  */
14927                     do_numlist:
14928                       for (;;)
14929                         {
14930                           unsigned int j;
14931
14932                           val = read_uleb128 (p, &j, end);
14933                           p += j;
14934                           if (val == 0)
14935                             break;
14936                           printf (" %d", val);
14937                         }
14938                       printf ("\n");
14939                       break;
14940                     default:
14941                       printf (_("Unknown tag: %d\n"), tag);
14942                       public_section = FALSE;
14943                       break;
14944                     }
14945
14946                   if (public_section && display_pub_attribute != NULL)
14947                     {
14948                       while (p < end)
14949                         p = display_pub_attribute (p, end);
14950                       assert (p == end);
14951                     }
14952                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14953                     {
14954                       while (p < end)
14955                         p = display_gnu_attribute (p,
14956                                                    display_proc_gnu_attribute,
14957                                                    end);
14958                       assert (p == end);
14959                     }
14960                   else if (p < end)
14961                     {
14962                       printf (_("  Unknown attribute:\n"));
14963                       display_raw_attribute (p, end);
14964                       p = end;
14965                     }
14966                   else
14967                     attr_len = 0;
14968                 }
14969             }
14970         }
14971
14972       free (contents);
14973     }
14974
14975   return res;
14976 }
14977
14978 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14979    Print the Address, Access and Initial fields of an entry at VMA ADDR
14980    and return the VMA of the next entry, or -1 if there was a problem.
14981    Does not read from DATA_END or beyond.  */
14982
14983 static bfd_vma
14984 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14985                       unsigned char * data_end)
14986 {
14987   printf ("  ");
14988   print_vma (addr, LONG_HEX);
14989   printf (" ");
14990   if (addr < pltgot + 0xfff0)
14991     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14992   else
14993     printf ("%10s", "");
14994   printf (" ");
14995   if (data == NULL)
14996     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14997   else
14998     {
14999       bfd_vma entry;
15000       unsigned char * from = data + addr - pltgot;
15001
15002       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15003         {
15004           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15005           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15006           return (bfd_vma) -1;
15007         }
15008       else
15009         {
15010           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15011           print_vma (entry, LONG_HEX);
15012         }
15013     }
15014   return addr + (is_32bit_elf ? 4 : 8);
15015 }
15016
15017 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15018    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15019    ADDR and return the VMA of the next entry.  */
15020
15021 static bfd_vma
15022 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15023 {
15024   printf ("  ");
15025   print_vma (addr, LONG_HEX);
15026   printf (" ");
15027   if (data == NULL)
15028     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15029   else
15030     {
15031       bfd_vma entry;
15032
15033       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15034       print_vma (entry, LONG_HEX);
15035     }
15036   return addr + (is_32bit_elf ? 4 : 8);
15037 }
15038
15039 static void
15040 print_mips_ases (unsigned int mask)
15041 {
15042   if (mask & AFL_ASE_DSP)
15043     fputs ("\n\tDSP ASE", stdout);
15044   if (mask & AFL_ASE_DSPR2)
15045     fputs ("\n\tDSP R2 ASE", stdout);
15046   if (mask & AFL_ASE_DSPR3)
15047     fputs ("\n\tDSP R3 ASE", stdout);
15048   if (mask & AFL_ASE_EVA)
15049     fputs ("\n\tEnhanced VA Scheme", stdout);
15050   if (mask & AFL_ASE_MCU)
15051     fputs ("\n\tMCU (MicroController) ASE", stdout);
15052   if (mask & AFL_ASE_MDMX)
15053     fputs ("\n\tMDMX ASE", stdout);
15054   if (mask & AFL_ASE_MIPS3D)
15055     fputs ("\n\tMIPS-3D ASE", stdout);
15056   if (mask & AFL_ASE_MT)
15057     fputs ("\n\tMT ASE", stdout);
15058   if (mask & AFL_ASE_SMARTMIPS)
15059     fputs ("\n\tSmartMIPS ASE", stdout);
15060   if (mask & AFL_ASE_VIRT)
15061     fputs ("\n\tVZ ASE", stdout);
15062   if (mask & AFL_ASE_MSA)
15063     fputs ("\n\tMSA ASE", stdout);
15064   if (mask & AFL_ASE_MIPS16)
15065     fputs ("\n\tMIPS16 ASE", stdout);
15066   if (mask & AFL_ASE_MICROMIPS)
15067     fputs ("\n\tMICROMIPS ASE", stdout);
15068   if (mask & AFL_ASE_XPA)
15069     fputs ("\n\tXPA ASE", stdout);
15070   if (mask & AFL_ASE_MIPS16E2)
15071     fputs ("\n\tMIPS16e2 ASE", stdout);
15072   if (mask == 0)
15073     fprintf (stdout, "\n\t%s", _("None"));
15074   else if ((mask & ~AFL_ASE_MASK) != 0)
15075     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15076 }
15077
15078 static void
15079 print_mips_isa_ext (unsigned int isa_ext)
15080 {
15081   switch (isa_ext)
15082     {
15083     case 0:
15084       fputs (_("None"), stdout);
15085       break;
15086     case AFL_EXT_XLR:
15087       fputs ("RMI XLR", stdout);
15088       break;
15089     case AFL_EXT_OCTEON3:
15090       fputs ("Cavium Networks Octeon3", stdout);
15091       break;
15092     case AFL_EXT_OCTEON2:
15093       fputs ("Cavium Networks Octeon2", stdout);
15094       break;
15095     case AFL_EXT_OCTEONP:
15096       fputs ("Cavium Networks OcteonP", stdout);
15097       break;
15098     case AFL_EXT_LOONGSON_3A:
15099       fputs ("Loongson 3A", stdout);
15100       break;
15101     case AFL_EXT_OCTEON:
15102       fputs ("Cavium Networks Octeon", stdout);
15103       break;
15104     case AFL_EXT_5900:
15105       fputs ("Toshiba R5900", stdout);
15106       break;
15107     case AFL_EXT_4650:
15108       fputs ("MIPS R4650", stdout);
15109       break;
15110     case AFL_EXT_4010:
15111       fputs ("LSI R4010", stdout);
15112       break;
15113     case AFL_EXT_4100:
15114       fputs ("NEC VR4100", stdout);
15115       break;
15116     case AFL_EXT_3900:
15117       fputs ("Toshiba R3900", stdout);
15118       break;
15119     case AFL_EXT_10000:
15120       fputs ("MIPS R10000", stdout);
15121       break;
15122     case AFL_EXT_SB1:
15123       fputs ("Broadcom SB-1", stdout);
15124       break;
15125     case AFL_EXT_4111:
15126       fputs ("NEC VR4111/VR4181", stdout);
15127       break;
15128     case AFL_EXT_4120:
15129       fputs ("NEC VR4120", stdout);
15130       break;
15131     case AFL_EXT_5400:
15132       fputs ("NEC VR5400", stdout);
15133       break;
15134     case AFL_EXT_5500:
15135       fputs ("NEC VR5500", stdout);
15136       break;
15137     case AFL_EXT_LOONGSON_2E:
15138       fputs ("ST Microelectronics Loongson 2E", stdout);
15139       break;
15140     case AFL_EXT_LOONGSON_2F:
15141       fputs ("ST Microelectronics Loongson 2F", stdout);
15142       break;
15143     case AFL_EXT_INTERAPTIV_MR2:
15144       fputs ("Imagination interAptiv MR2", stdout);
15145       break;
15146     default:
15147       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15148     }
15149 }
15150
15151 static signed int
15152 get_mips_reg_size (int reg_size)
15153 {
15154   return (reg_size == AFL_REG_NONE) ? 0
15155          : (reg_size == AFL_REG_32) ? 32
15156          : (reg_size == AFL_REG_64) ? 64
15157          : (reg_size == AFL_REG_128) ? 128
15158          : -1;
15159 }
15160
15161 static bfd_boolean
15162 process_mips_specific (FILE * file)
15163 {
15164   Elf_Internal_Dyn * entry;
15165   Elf_Internal_Shdr *sect = NULL;
15166   size_t liblist_offset = 0;
15167   size_t liblistno = 0;
15168   size_t conflictsno = 0;
15169   size_t options_offset = 0;
15170   size_t conflicts_offset = 0;
15171   size_t pltrelsz = 0;
15172   size_t pltrel = 0;
15173   bfd_vma pltgot = 0;
15174   bfd_vma mips_pltgot = 0;
15175   bfd_vma jmprel = 0;
15176   bfd_vma local_gotno = 0;
15177   bfd_vma gotsym = 0;
15178   bfd_vma symtabno = 0;
15179   bfd_boolean res = TRUE;
15180
15181   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15182                             display_mips_gnu_attribute))
15183     res = FALSE;
15184
15185   sect = find_section (".MIPS.abiflags");
15186
15187   if (sect != NULL)
15188     {
15189       Elf_External_ABIFlags_v0 *abiflags_ext;
15190       Elf_Internal_ABIFlags_v0 abiflags_in;
15191
15192       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15193         {
15194           error (_("Corrupt MIPS ABI Flags section.\n"));
15195           res = FALSE;
15196         }
15197       else
15198         {
15199           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15200                                    sect->sh_size, _("MIPS ABI Flags section"));
15201           if (abiflags_ext)
15202             {
15203               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15204               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15205               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15206               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15207               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15208               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15209               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15210               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15211               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15212               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15213               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15214
15215               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15216               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15217               if (abiflags_in.isa_rev > 1)
15218                 printf ("r%d", abiflags_in.isa_rev);
15219               printf ("\nGPR size: %d",
15220                       get_mips_reg_size (abiflags_in.gpr_size));
15221               printf ("\nCPR1 size: %d",
15222                       get_mips_reg_size (abiflags_in.cpr1_size));
15223               printf ("\nCPR2 size: %d",
15224                       get_mips_reg_size (abiflags_in.cpr2_size));
15225               fputs ("\nFP ABI: ", stdout);
15226               print_mips_fp_abi_value (abiflags_in.fp_abi);
15227               fputs ("ISA Extension: ", stdout);
15228               print_mips_isa_ext (abiflags_in.isa_ext);
15229               fputs ("\nASEs:", stdout);
15230               print_mips_ases (abiflags_in.ases);
15231               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15232               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15233               fputc ('\n', stdout);
15234               free (abiflags_ext);
15235             }
15236         }
15237     }
15238
15239   /* We have a lot of special sections.  Thanks SGI!  */
15240   if (dynamic_section == NULL)
15241     {
15242       /* No dynamic information available.  See if there is static GOT.  */
15243       sect = find_section (".got");
15244       if (sect != NULL)
15245         {
15246           unsigned char *data_end;
15247           unsigned char *data;
15248           bfd_vma ent, end;
15249           int addr_size;
15250
15251           pltgot = sect->sh_addr;
15252
15253           ent = pltgot;
15254           addr_size = (is_32bit_elf ? 4 : 8);
15255           end = pltgot + sect->sh_size;
15256
15257           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15258                                              end - pltgot, 1,
15259                                              _("Global Offset Table data"));
15260           /* PR 12855: Null data is handled gracefully throughout.  */
15261           data_end = data + (end - pltgot);
15262
15263           printf (_("\nStatic GOT:\n"));
15264           printf (_(" Canonical gp value: "));
15265           print_vma (ent + 0x7ff0, LONG_HEX);
15266           printf ("\n\n");
15267
15268           /* In a dynamic binary GOT[0] is reserved for the dynamic
15269              loader to store the lazy resolver pointer, however in
15270              a static binary it may well have been omitted and GOT
15271              reduced to a table of addresses.
15272              PR 21344: Check for the entry being fully available
15273              before fetching it.  */
15274           if (data
15275               && data + ent - pltgot + addr_size <= data_end
15276               && byte_get (data + ent - pltgot, addr_size) == 0)
15277             {
15278               printf (_(" Reserved entries:\n"));
15279               printf (_("  %*s %10s %*s\n"),
15280                       addr_size * 2, _("Address"), _("Access"),
15281                       addr_size * 2, _("Value"));
15282               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15283               printf ("\n");
15284               if (ent == (bfd_vma) -1)
15285                 goto sgot_print_fail;
15286
15287               /* Check for the MSB of GOT[1] being set, identifying a
15288                  GNU object.  This entry will be used by some runtime
15289                  loaders, to store the module pointer.  Otherwise this
15290                  is an ordinary local entry.
15291                  PR 21344: Check for the entry being fully available
15292                  before fetching it.  */
15293               if (data
15294                   && data + ent - pltgot + addr_size <= data_end
15295                   && (byte_get (data + ent - pltgot, addr_size)
15296                       >> (addr_size * 8 - 1)) != 0)
15297                 {
15298                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15299                   printf ("\n");
15300                   if (ent == (bfd_vma) -1)
15301                     goto sgot_print_fail;
15302                 }
15303               printf ("\n");
15304             }
15305
15306           if (ent < end)
15307             {
15308               printf (_(" Local entries:\n"));
15309               printf ("  %*s %10s %*s\n",
15310                       addr_size * 2, _("Address"), _("Access"),
15311                       addr_size * 2, _("Value"));
15312               while (ent < end)
15313                 {
15314                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15315                   printf ("\n");
15316                   if (ent == (bfd_vma) -1)
15317                     goto sgot_print_fail;
15318                 }
15319               printf ("\n");
15320             }
15321
15322         sgot_print_fail:
15323           if (data)
15324             free (data);
15325         }
15326       return res;
15327     }
15328
15329   for (entry = dynamic_section;
15330        /* PR 17531 file: 012-50589-0.004.  */
15331        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15332        ++entry)
15333     switch (entry->d_tag)
15334       {
15335       case DT_MIPS_LIBLIST:
15336         liblist_offset
15337           = offset_from_vma (file, entry->d_un.d_val,
15338                              liblistno * sizeof (Elf32_External_Lib));
15339         break;
15340       case DT_MIPS_LIBLISTNO:
15341         liblistno = entry->d_un.d_val;
15342         break;
15343       case DT_MIPS_OPTIONS:
15344         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15345         break;
15346       case DT_MIPS_CONFLICT:
15347         conflicts_offset
15348           = offset_from_vma (file, entry->d_un.d_val,
15349                              conflictsno * sizeof (Elf32_External_Conflict));
15350         break;
15351       case DT_MIPS_CONFLICTNO:
15352         conflictsno = entry->d_un.d_val;
15353         break;
15354       case DT_PLTGOT:
15355         pltgot = entry->d_un.d_ptr;
15356         break;
15357       case DT_MIPS_LOCAL_GOTNO:
15358         local_gotno = entry->d_un.d_val;
15359         break;
15360       case DT_MIPS_GOTSYM:
15361         gotsym = entry->d_un.d_val;
15362         break;
15363       case DT_MIPS_SYMTABNO:
15364         symtabno = entry->d_un.d_val;
15365         break;
15366       case DT_MIPS_PLTGOT:
15367         mips_pltgot = entry->d_un.d_ptr;
15368         break;
15369       case DT_PLTREL:
15370         pltrel = entry->d_un.d_val;
15371         break;
15372       case DT_PLTRELSZ:
15373         pltrelsz = entry->d_un.d_val;
15374         break;
15375       case DT_JMPREL:
15376         jmprel = entry->d_un.d_ptr;
15377         break;
15378       default:
15379         break;
15380       }
15381
15382   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15383     {
15384       Elf32_External_Lib * elib;
15385       size_t cnt;
15386
15387       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15388                                               liblistno,
15389                                               sizeof (Elf32_External_Lib),
15390                                               _("liblist section data"));
15391       if (elib)
15392         {
15393           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15394                   (unsigned long) liblistno);
15395           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15396                  stdout);
15397
15398           for (cnt = 0; cnt < liblistno; ++cnt)
15399             {
15400               Elf32_Lib liblist;
15401               time_t atime;
15402               char timebuf[128];
15403               struct tm * tmp;
15404
15405               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15406               atime = BYTE_GET (elib[cnt].l_time_stamp);
15407               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15408               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15409               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15410
15411               tmp = gmtime (&atime);
15412               snprintf (timebuf, sizeof (timebuf),
15413                         "%04u-%02u-%02uT%02u:%02u:%02u",
15414                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15415                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15416
15417               printf ("%3lu: ", (unsigned long) cnt);
15418               if (VALID_DYNAMIC_NAME (liblist.l_name))
15419                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15420               else
15421                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15422               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15423                       liblist.l_version);
15424
15425               if (liblist.l_flags == 0)
15426                 puts (_(" NONE"));
15427               else
15428                 {
15429                   static const struct
15430                   {
15431                     const char * name;
15432                     int bit;
15433                   }
15434                   l_flags_vals[] =
15435                   {
15436                     { " EXACT_MATCH", LL_EXACT_MATCH },
15437                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15438                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15439                     { " EXPORTS", LL_EXPORTS },
15440                     { " DELAY_LOAD", LL_DELAY_LOAD },
15441                     { " DELTA", LL_DELTA }
15442                   };
15443                   int flags = liblist.l_flags;
15444                   size_t fcnt;
15445
15446                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15447                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15448                       {
15449                         fputs (l_flags_vals[fcnt].name, stdout);
15450                         flags ^= l_flags_vals[fcnt].bit;
15451                       }
15452                   if (flags != 0)
15453                     printf (" %#x", (unsigned int) flags);
15454
15455                   puts ("");
15456                 }
15457             }
15458
15459           free (elib);
15460         }
15461       else
15462         res = FALSE;
15463     }
15464
15465   if (options_offset != 0)
15466     {
15467       Elf_External_Options * eopt;
15468       Elf_Internal_Options * iopt;
15469       Elf_Internal_Options * option;
15470       size_t offset;
15471       int cnt;
15472       sect = section_headers;
15473
15474       /* Find the section header so that we get the size.  */
15475       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15476       /* PR 17533 file: 012-277276-0.004.  */
15477       if (sect == NULL)
15478         {
15479           error (_("No MIPS_OPTIONS header found\n"));
15480           return FALSE;
15481         }
15482
15483       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15484                                                 sect->sh_size, _("options"));
15485       if (eopt)
15486         {
15487           iopt = (Elf_Internal_Options *)
15488               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15489           if (iopt == NULL)
15490             {
15491               error (_("Out of memory allocating space for MIPS options\n"));
15492               return FALSE;
15493             }
15494
15495           offset = cnt = 0;
15496           option = iopt;
15497
15498           while (offset <= sect->sh_size - sizeof (* eopt))
15499             {
15500               Elf_External_Options * eoption;
15501
15502               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15503
15504               option->kind = BYTE_GET (eoption->kind);
15505               option->size = BYTE_GET (eoption->size);
15506               option->section = BYTE_GET (eoption->section);
15507               option->info = BYTE_GET (eoption->info);
15508
15509               /* PR 17531: file: ffa0fa3b.  */
15510               if (option->size < sizeof (* eopt)
15511                   || offset + option->size > sect->sh_size)
15512                 {
15513                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15514                   return FALSE;
15515                 }
15516               offset += option->size;
15517
15518               ++option;
15519               ++cnt;
15520             }
15521
15522           printf (_("\nSection '%s' contains %d entries:\n"),
15523                   printable_section_name (sect), cnt);
15524
15525           option = iopt;
15526           offset = 0;
15527
15528           while (cnt-- > 0)
15529             {
15530               size_t len;
15531
15532               switch (option->kind)
15533                 {
15534                 case ODK_NULL:
15535                   /* This shouldn't happen.  */
15536                   printf (" NULL       %d %lx", option->section, option->info);
15537                   break;
15538                 case ODK_REGINFO:
15539                   printf (" REGINFO    ");
15540                   if (elf_header.e_machine == EM_MIPS)
15541                     {
15542                       /* 32bit form.  */
15543                       Elf32_External_RegInfo * ereg;
15544                       Elf32_RegInfo reginfo;
15545
15546                       ereg = (Elf32_External_RegInfo *) (option + 1);
15547                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15548                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15549                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15550                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15551                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15552                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15553
15554                       printf ("GPR %08lx  GP 0x%lx\n",
15555                               reginfo.ri_gprmask,
15556                               (unsigned long) reginfo.ri_gp_value);
15557                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15558                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15559                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15560                     }
15561                   else
15562                     {
15563                       /* 64 bit form.  */
15564                       Elf64_External_RegInfo * ereg;
15565                       Elf64_Internal_RegInfo reginfo;
15566
15567                       ereg = (Elf64_External_RegInfo *) (option + 1);
15568                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15569                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15570                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15571                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15572                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15573                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15574
15575                       printf ("GPR %08lx  GP 0x",
15576                               reginfo.ri_gprmask);
15577                       printf_vma (reginfo.ri_gp_value);
15578                       printf ("\n");
15579
15580                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15581                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15582                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15583                     }
15584                   ++option;
15585                   continue;
15586                 case ODK_EXCEPTIONS:
15587                   fputs (" EXCEPTIONS fpe_min(", stdout);
15588                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15589                   fputs (") fpe_max(", stdout);
15590                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15591                   fputs (")", stdout);
15592
15593                   if (option->info & OEX_PAGE0)
15594                     fputs (" PAGE0", stdout);
15595                   if (option->info & OEX_SMM)
15596                     fputs (" SMM", stdout);
15597                   if (option->info & OEX_FPDBUG)
15598                     fputs (" FPDBUG", stdout);
15599                   if (option->info & OEX_DISMISS)
15600                     fputs (" DISMISS", stdout);
15601                   break;
15602                 case ODK_PAD:
15603                   fputs (" PAD       ", stdout);
15604                   if (option->info & OPAD_PREFIX)
15605                     fputs (" PREFIX", stdout);
15606                   if (option->info & OPAD_POSTFIX)
15607                     fputs (" POSTFIX", stdout);
15608                   if (option->info & OPAD_SYMBOL)
15609                     fputs (" SYMBOL", stdout);
15610                   break;
15611                 case ODK_HWPATCH:
15612                   fputs (" HWPATCH   ", stdout);
15613                   if (option->info & OHW_R4KEOP)
15614                     fputs (" R4KEOP", stdout);
15615                   if (option->info & OHW_R8KPFETCH)
15616                     fputs (" R8KPFETCH", stdout);
15617                   if (option->info & OHW_R5KEOP)
15618                     fputs (" R5KEOP", stdout);
15619                   if (option->info & OHW_R5KCVTL)
15620                     fputs (" R5KCVTL", stdout);
15621                   break;
15622                 case ODK_FILL:
15623                   fputs (" FILL       ", stdout);
15624                   /* XXX Print content of info word?  */
15625                   break;
15626                 case ODK_TAGS:
15627                   fputs (" TAGS       ", stdout);
15628                   /* XXX Print content of info word?  */
15629                   break;
15630                 case ODK_HWAND:
15631                   fputs (" HWAND     ", stdout);
15632                   if (option->info & OHWA0_R4KEOP_CHECKED)
15633                     fputs (" R4KEOP_CHECKED", stdout);
15634                   if (option->info & OHWA0_R4KEOP_CLEAN)
15635                     fputs (" R4KEOP_CLEAN", stdout);
15636                   break;
15637                 case ODK_HWOR:
15638                   fputs (" HWOR      ", stdout);
15639                   if (option->info & OHWA0_R4KEOP_CHECKED)
15640                     fputs (" R4KEOP_CHECKED", stdout);
15641                   if (option->info & OHWA0_R4KEOP_CLEAN)
15642                     fputs (" R4KEOP_CLEAN", stdout);
15643                   break;
15644                 case ODK_GP_GROUP:
15645                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15646                           option->info & OGP_GROUP,
15647                           (option->info & OGP_SELF) >> 16);
15648                   break;
15649                 case ODK_IDENT:
15650                   printf (" IDENT     %#06lx  self-contained %#06lx",
15651                           option->info & OGP_GROUP,
15652                           (option->info & OGP_SELF) >> 16);
15653                   break;
15654                 default:
15655                   /* This shouldn't happen.  */
15656                   printf (" %3d ???     %d %lx",
15657                           option->kind, option->section, option->info);
15658                   break;
15659                 }
15660
15661               len = sizeof (* eopt);
15662               while (len < option->size)
15663                 {
15664                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15665
15666                   if (ISPRINT (datum))
15667                     printf ("%c", datum);
15668                   else
15669                     printf ("\\%03o", datum);
15670                   len ++;
15671                 }
15672               fputs ("\n", stdout);
15673
15674               offset += option->size;
15675               ++option;
15676             }
15677
15678           free (eopt);
15679         }
15680       else
15681         res = FALSE;
15682     }
15683
15684   if (conflicts_offset != 0 && conflictsno != 0)
15685     {
15686       Elf32_Conflict * iconf;
15687       size_t cnt;
15688
15689       if (dynamic_symbols == NULL)
15690         {
15691           error (_("conflict list found without a dynamic symbol table\n"));
15692           return FALSE;
15693         }
15694
15695       /* PR 21345 - print a slightly more helpful error message
15696          if we are sure that the cmalloc will fail.  */
15697       if (conflictsno * sizeof (* iconf) > current_file_size)
15698         {
15699           error (_("Overlarge number of conflicts detected: %lx\n"),
15700                  (long) conflictsno);
15701           return FALSE;
15702         }
15703
15704       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15705       if (iconf == NULL)
15706         {
15707           error (_("Out of memory allocating space for dynamic conflicts\n"));
15708           return FALSE;
15709         }
15710
15711       if (is_32bit_elf)
15712         {
15713           Elf32_External_Conflict * econf32;
15714
15715           econf32 = (Elf32_External_Conflict *)
15716               get_data (NULL, file, conflicts_offset, conflictsno,
15717                         sizeof (* econf32), _("conflict"));
15718           if (!econf32)
15719             return FALSE;
15720
15721           for (cnt = 0; cnt < conflictsno; ++cnt)
15722             iconf[cnt] = BYTE_GET (econf32[cnt]);
15723
15724           free (econf32);
15725         }
15726       else
15727         {
15728           Elf64_External_Conflict * econf64;
15729
15730           econf64 = (Elf64_External_Conflict *)
15731               get_data (NULL, file, conflicts_offset, conflictsno,
15732                         sizeof (* econf64), _("conflict"));
15733           if (!econf64)
15734             return FALSE;
15735
15736           for (cnt = 0; cnt < conflictsno; ++cnt)
15737             iconf[cnt] = BYTE_GET (econf64[cnt]);
15738
15739           free (econf64);
15740         }
15741
15742       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15743               (unsigned long) conflictsno);
15744       puts (_("  Num:    Index       Value  Name"));
15745
15746       for (cnt = 0; cnt < conflictsno; ++cnt)
15747         {
15748           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15749
15750           if (iconf[cnt] >= num_dynamic_syms)
15751             printf (_("<corrupt symbol index>"));
15752           else
15753             {
15754               Elf_Internal_Sym * psym;
15755
15756               psym = & dynamic_symbols[iconf[cnt]];
15757               print_vma (psym->st_value, FULL_HEX);
15758               putchar (' ');
15759               if (VALID_DYNAMIC_NAME (psym->st_name))
15760                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15761               else
15762                 printf (_("<corrupt: %14ld>"), psym->st_name);
15763             }
15764           putchar ('\n');
15765         }
15766
15767       free (iconf);
15768     }
15769
15770   if (pltgot != 0 && local_gotno != 0)
15771     {
15772       bfd_vma ent, local_end, global_end;
15773       size_t i, offset;
15774       unsigned char * data;
15775       unsigned char * data_end;
15776       int addr_size;
15777
15778       ent = pltgot;
15779       addr_size = (is_32bit_elf ? 4 : 8);
15780       local_end = pltgot + local_gotno * addr_size;
15781
15782       /* PR binutils/17533 file: 012-111227-0.004  */
15783       if (symtabno < gotsym)
15784         {
15785           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15786                  (unsigned long) gotsym, (unsigned long) symtabno);
15787           return FALSE;
15788         }
15789
15790       global_end = local_end + (symtabno - gotsym) * addr_size;
15791       /* PR 17531: file: 54c91a34.  */
15792       if (global_end < local_end)
15793         {
15794           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15795           return FALSE;
15796         }
15797
15798       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15799       data = (unsigned char *) get_data (NULL, file, offset,
15800                                          global_end - pltgot, 1,
15801                                          _("Global Offset Table data"));
15802       /* PR 12855: Null data is handled gracefully throughout.  */
15803       data_end = data + (global_end - pltgot);
15804
15805       printf (_("\nPrimary GOT:\n"));
15806       printf (_(" Canonical gp value: "));
15807       print_vma (pltgot + 0x7ff0, LONG_HEX);
15808       printf ("\n\n");
15809
15810       printf (_(" Reserved entries:\n"));
15811       printf (_("  %*s %10s %*s Purpose\n"),
15812               addr_size * 2, _("Address"), _("Access"),
15813               addr_size * 2, _("Initial"));
15814       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15815       printf (_(" Lazy resolver\n"));
15816       if (ent == (bfd_vma) -1)
15817         goto got_print_fail;
15818
15819       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15820          This entry will be used by some runtime loaders, to store the
15821          module pointer.  Otherwise this is an ordinary local entry.
15822          PR 21344: Check for the entry being fully available before
15823          fetching it.  */
15824       if (data
15825           && data + ent - pltgot + addr_size <= data_end
15826           && (byte_get (data + ent - pltgot, addr_size)
15827               >> (addr_size * 8 - 1)) != 0)
15828         {
15829           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15830           printf (_(" Module pointer (GNU extension)\n"));
15831           if (ent == (bfd_vma) -1)
15832             goto got_print_fail;
15833         }
15834       printf ("\n");
15835
15836       if (ent < local_end)
15837         {
15838           printf (_(" Local entries:\n"));
15839           printf ("  %*s %10s %*s\n",
15840                   addr_size * 2, _("Address"), _("Access"),
15841                   addr_size * 2, _("Initial"));
15842           while (ent < local_end)
15843             {
15844               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15845               printf ("\n");
15846               if (ent == (bfd_vma) -1)
15847                 goto got_print_fail;
15848             }
15849           printf ("\n");
15850         }
15851
15852       if (gotsym < symtabno)
15853         {
15854           int sym_width;
15855
15856           printf (_(" Global entries:\n"));
15857           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15858                   addr_size * 2, _("Address"),
15859                   _("Access"),
15860                   addr_size * 2, _("Initial"),
15861                   addr_size * 2, _("Sym.Val."),
15862                   _("Type"),
15863                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15864                   _("Ndx"), _("Name"));
15865
15866           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15867
15868           for (i = gotsym; i < symtabno; i++)
15869             {
15870               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15871               printf (" ");
15872
15873               if (dynamic_symbols == NULL)
15874                 printf (_("<no dynamic symbols>"));
15875               else if (i < num_dynamic_syms)
15876                 {
15877                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15878
15879                   print_vma (psym->st_value, LONG_HEX);
15880                   printf (" %-7s %3s ",
15881                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15882                           get_symbol_index_type (psym->st_shndx));
15883
15884                   if (VALID_DYNAMIC_NAME (psym->st_name))
15885                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15886                   else
15887                     printf (_("<corrupt: %14ld>"), psym->st_name);
15888                 }
15889               else
15890                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15891                         (unsigned long) i);
15892
15893               printf ("\n");
15894               if (ent == (bfd_vma) -1)
15895                 break;
15896             }
15897           printf ("\n");
15898         }
15899
15900     got_print_fail:
15901       if (data)
15902         free (data);
15903     }
15904
15905   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15906     {
15907       bfd_vma ent, end;
15908       size_t offset, rel_offset;
15909       unsigned long count, i;
15910       unsigned char * data;
15911       int addr_size, sym_width;
15912       Elf_Internal_Rela * rels;
15913
15914       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15915       if (pltrel == DT_RELA)
15916         {
15917           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15918             return FALSE;
15919         }
15920       else
15921         {
15922           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15923             return FALSE;
15924         }
15925
15926       ent = mips_pltgot;
15927       addr_size = (is_32bit_elf ? 4 : 8);
15928       end = mips_pltgot + (2 + count) * addr_size;
15929
15930       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15931       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15932                                          1, _("Procedure Linkage Table data"));
15933       if (data == NULL)
15934         return FALSE;
15935
15936       printf ("\nPLT GOT:\n\n");
15937       printf (_(" Reserved entries:\n"));
15938       printf (_("  %*s %*s Purpose\n"),
15939               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15940       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15941       printf (_(" PLT lazy resolver\n"));
15942       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15943       printf (_(" Module pointer\n"));
15944       printf ("\n");
15945
15946       printf (_(" Entries:\n"));
15947       printf ("  %*s %*s %*s %-7s %3s %s\n",
15948               addr_size * 2, _("Address"),
15949               addr_size * 2, _("Initial"),
15950               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15951       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15952       for (i = 0; i < count; i++)
15953         {
15954           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15955
15956           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15957           printf (" ");
15958
15959           if (idx >= num_dynamic_syms)
15960             printf (_("<corrupt symbol index: %lu>"), idx);
15961           else
15962             {
15963               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15964
15965               print_vma (psym->st_value, LONG_HEX);
15966               printf (" %-7s %3s ",
15967                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15968                       get_symbol_index_type (psym->st_shndx));
15969               if (VALID_DYNAMIC_NAME (psym->st_name))
15970                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15971               else
15972                 printf (_("<corrupt: %14ld>"), psym->st_name);
15973             }
15974           printf ("\n");
15975         }
15976       printf ("\n");
15977
15978       if (data)
15979         free (data);
15980       free (rels);
15981     }
15982
15983   return res;
15984 }
15985
15986 static bfd_boolean
15987 process_nds32_specific (FILE * file)
15988 {
15989   Elf_Internal_Shdr *sect = NULL;
15990
15991   sect = find_section (".nds32_e_flags");
15992   if (sect != NULL)
15993     {
15994       unsigned int *flag;
15995
15996       printf ("\nNDS32 elf flags section:\n");
15997       flag = get_data (NULL, file, sect->sh_offset, 1,
15998                        sect->sh_size, _("NDS32 elf flags section"));
15999
16000       if (! flag)
16001         return FALSE;
16002
16003       switch ((*flag) & 0x3)
16004         {
16005         case 0:
16006           printf ("(VEC_SIZE):\tNo entry.\n");
16007           break;
16008         case 1:
16009           printf ("(VEC_SIZE):\t4 bytes\n");
16010           break;
16011         case 2:
16012           printf ("(VEC_SIZE):\t16 bytes\n");
16013           break;
16014         case 3:
16015           printf ("(VEC_SIZE):\treserved\n");
16016           break;
16017         }
16018     }
16019
16020   return TRUE;
16021 }
16022
16023 static bfd_boolean
16024 process_gnu_liblist (FILE * file)
16025 {
16026   Elf_Internal_Shdr * section;
16027   Elf_Internal_Shdr * string_sec;
16028   Elf32_External_Lib * elib;
16029   char * strtab;
16030   size_t strtab_size;
16031   size_t cnt;
16032   unsigned i;
16033   bfd_boolean res = TRUE;
16034
16035   if (! do_arch)
16036     return TRUE;
16037
16038   for (i = 0, section = section_headers;
16039        i < elf_header.e_shnum;
16040        i++, section++)
16041     {
16042       switch (section->sh_type)
16043         {
16044         case SHT_GNU_LIBLIST:
16045           if (section->sh_link >= elf_header.e_shnum)
16046             break;
16047
16048           elib = (Elf32_External_Lib *)
16049               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16050                         _("liblist section data"));
16051
16052           if (elib == NULL)
16053             {
16054               res = FALSE;
16055               break;
16056             }
16057
16058           string_sec = section_headers + section->sh_link;
16059           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16060                                       string_sec->sh_size,
16061                                       _("liblist string table"));
16062           if (strtab == NULL
16063               || section->sh_entsize != sizeof (Elf32_External_Lib))
16064             {
16065               free (elib);
16066               free (strtab);
16067               res = FALSE;
16068               break;
16069             }
16070           strtab_size = string_sec->sh_size;
16071
16072           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16073                   printable_section_name (section),
16074                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16075
16076           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16077
16078           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16079                ++cnt)
16080             {
16081               Elf32_Lib liblist;
16082               time_t atime;
16083               char timebuf[128];
16084               struct tm * tmp;
16085
16086               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16087               atime = BYTE_GET (elib[cnt].l_time_stamp);
16088               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16089               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16090               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16091
16092               tmp = gmtime (&atime);
16093               snprintf (timebuf, sizeof (timebuf),
16094                         "%04u-%02u-%02uT%02u:%02u:%02u",
16095                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16096                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16097
16098               printf ("%3lu: ", (unsigned long) cnt);
16099               if (do_wide)
16100                 printf ("%-20s", liblist.l_name < strtab_size
16101                         ? strtab + liblist.l_name : _("<corrupt>"));
16102               else
16103                 printf ("%-20.20s", liblist.l_name < strtab_size
16104                         ? strtab + liblist.l_name : _("<corrupt>"));
16105               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16106                       liblist.l_version, liblist.l_flags);
16107             }
16108
16109           free (elib);
16110           free (strtab);
16111         }
16112     }
16113
16114   return res;
16115 }
16116
16117 static const char *
16118 get_note_type (unsigned e_type)
16119 {
16120   static char buff[64];
16121
16122   if (elf_header.e_type == ET_CORE)
16123     switch (e_type)
16124       {
16125       case NT_AUXV:
16126         return _("NT_AUXV (auxiliary vector)");
16127       case NT_PRSTATUS:
16128         return _("NT_PRSTATUS (prstatus structure)");
16129       case NT_FPREGSET:
16130         return _("NT_FPREGSET (floating point registers)");
16131       case NT_PRPSINFO:
16132         return _("NT_PRPSINFO (prpsinfo structure)");
16133       case NT_TASKSTRUCT:
16134         return _("NT_TASKSTRUCT (task structure)");
16135       case NT_PRXFPREG:
16136         return _("NT_PRXFPREG (user_xfpregs structure)");
16137       case NT_PPC_VMX:
16138         return _("NT_PPC_VMX (ppc Altivec registers)");
16139       case NT_PPC_VSX:
16140         return _("NT_PPC_VSX (ppc VSX registers)");
16141       case NT_PPC_TAR:
16142         return _("NT_PPC_TAR (ppc TAR register)");
16143       case NT_PPC_PPR:
16144         return _("NT_PPC_PPR (ppc PPR register)");
16145       case NT_PPC_DSCR:
16146         return _("NT_PPC_DSCR (ppc DSCR register)");
16147       case NT_PPC_EBB:
16148         return _("NT_PPC_EBB (ppc EBB registers)");
16149       case NT_PPC_PMU:
16150         return _("NT_PPC_PMU (ppc PMU registers)");
16151       case NT_PPC_TM_CGPR:
16152         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16153       case NT_PPC_TM_CFPR:
16154         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16155       case NT_PPC_TM_CVMX:
16156         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16157       case NT_PPC_TM_CVSX:
16158         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16159       case NT_PPC_TM_SPR:
16160         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16161       case NT_PPC_TM_CTAR:
16162         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16163       case NT_PPC_TM_CPPR:
16164         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16165       case NT_PPC_TM_CDSCR:
16166         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16167       case NT_386_TLS:
16168         return _("NT_386_TLS (x86 TLS information)");
16169       case NT_386_IOPERM:
16170         return _("NT_386_IOPERM (x86 I/O permissions)");
16171       case NT_X86_XSTATE:
16172         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16173       case NT_S390_HIGH_GPRS:
16174         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16175       case NT_S390_TIMER:
16176         return _("NT_S390_TIMER (s390 timer register)");
16177       case NT_S390_TODCMP:
16178         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16179       case NT_S390_TODPREG:
16180         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16181       case NT_S390_CTRS:
16182         return _("NT_S390_CTRS (s390 control registers)");
16183       case NT_S390_PREFIX:
16184         return _("NT_S390_PREFIX (s390 prefix register)");
16185       case NT_S390_LAST_BREAK:
16186         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16187       case NT_S390_SYSTEM_CALL:
16188         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16189       case NT_S390_TDB:
16190         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16191       case NT_S390_VXRS_LOW:
16192         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16193       case NT_S390_VXRS_HIGH:
16194         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16195       case NT_S390_GS_CB:
16196         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16197       case NT_S390_GS_BC:
16198         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16199       case NT_ARM_VFP:
16200         return _("NT_ARM_VFP (arm VFP registers)");
16201       case NT_ARM_TLS:
16202         return _("NT_ARM_TLS (AArch TLS registers)");
16203       case NT_ARM_HW_BREAK:
16204         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16205       case NT_ARM_HW_WATCH:
16206         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16207       case NT_PSTATUS:
16208         return _("NT_PSTATUS (pstatus structure)");
16209       case NT_FPREGS:
16210         return _("NT_FPREGS (floating point registers)");
16211       case NT_PSINFO:
16212         return _("NT_PSINFO (psinfo structure)");
16213       case NT_LWPSTATUS:
16214         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16215       case NT_LWPSINFO:
16216         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16217       case NT_WIN32PSTATUS:
16218         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16219       case NT_SIGINFO:
16220         return _("NT_SIGINFO (siginfo_t data)");
16221       case NT_FILE:
16222         return _("NT_FILE (mapped files)");
16223       default:
16224         break;
16225       }
16226   else
16227     switch (e_type)
16228       {
16229       case NT_VERSION:
16230         return _("NT_VERSION (version)");
16231       case NT_ARCH:
16232         return _("NT_ARCH (architecture)");
16233       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16234         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16235       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16236         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16237       default:
16238         break;
16239       }
16240
16241   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16242   return buff;
16243 }
16244
16245 static bfd_boolean
16246 print_core_note (Elf_Internal_Note *pnote)
16247 {
16248   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16249   bfd_vma count, page_size;
16250   unsigned char *descdata, *filenames, *descend;
16251
16252   if (pnote->type != NT_FILE)
16253     {
16254       if (do_wide)
16255         printf ("\n");
16256       return TRUE;
16257     }
16258
16259 #ifndef BFD64
16260   if (!is_32bit_elf)
16261     {
16262       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16263       /* Still "successful".  */
16264       return TRUE;
16265     }
16266 #endif
16267
16268   if (pnote->descsz < 2 * addr_size)
16269     {
16270       error (_("    Malformed note - too short for header\n"));
16271       return FALSE;
16272     }
16273
16274   descdata = (unsigned char *) pnote->descdata;
16275   descend = descdata + pnote->descsz;
16276
16277   if (descdata[pnote->descsz - 1] != '\0')
16278     {
16279       error (_("    Malformed note - does not end with \\0\n"));
16280       return FALSE;
16281     }
16282
16283   count = byte_get (descdata, addr_size);
16284   descdata += addr_size;
16285
16286   page_size = byte_get (descdata, addr_size);
16287   descdata += addr_size;
16288
16289   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16290     {
16291       error (_("    Malformed note - too short for supplied file count\n"));
16292       return FALSE;
16293     }
16294
16295   printf (_("    Page size: "));
16296   print_vma (page_size, DEC);
16297   printf ("\n");
16298
16299   printf (_("    %*s%*s%*s\n"),
16300           (int) (2 + 2 * addr_size), _("Start"),
16301           (int) (4 + 2 * addr_size), _("End"),
16302           (int) (4 + 2 * addr_size), _("Page Offset"));
16303   filenames = descdata + count * 3 * addr_size;
16304   while (count-- > 0)
16305     {
16306       bfd_vma start, end, file_ofs;
16307
16308       if (filenames == descend)
16309         {
16310           error (_("    Malformed note - filenames end too early\n"));
16311           return FALSE;
16312         }
16313
16314       start = byte_get (descdata, addr_size);
16315       descdata += addr_size;
16316       end = byte_get (descdata, addr_size);
16317       descdata += addr_size;
16318       file_ofs = byte_get (descdata, addr_size);
16319       descdata += addr_size;
16320
16321       printf ("    ");
16322       print_vma (start, FULL_HEX);
16323       printf ("  ");
16324       print_vma (end, FULL_HEX);
16325       printf ("  ");
16326       print_vma (file_ofs, FULL_HEX);
16327       printf ("\n        %s\n", filenames);
16328
16329       filenames += 1 + strlen ((char *) filenames);
16330     }
16331
16332   return TRUE;
16333 }
16334
16335 static const char *
16336 get_gnu_elf_note_type (unsigned e_type)
16337 {
16338   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16339   switch (e_type)
16340     {
16341     case NT_GNU_ABI_TAG:
16342       return _("NT_GNU_ABI_TAG (ABI version tag)");
16343     case NT_GNU_HWCAP:
16344       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16345     case NT_GNU_BUILD_ID:
16346       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16347     case NT_GNU_GOLD_VERSION:
16348       return _("NT_GNU_GOLD_VERSION (gold version)");
16349     case NT_GNU_PROPERTY_TYPE_0:
16350       return _("NT_GNU_PROPERTY_TYPE_0");
16351     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16352       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16353     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16354       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16355     default:
16356       {
16357         static char buff[64];
16358
16359         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16360         return buff;
16361       }
16362     }
16363 }
16364
16365 static void
16366 decode_x86_isa (unsigned int bitmask)
16367 {
16368   while (bitmask)
16369     {
16370       unsigned int bit = bitmask & (- bitmask);
16371
16372       bitmask &= ~ bit;
16373       switch (bit)
16374         {
16375         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16376         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16377         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16378         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16379         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16380         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16381         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16382         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16383         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16384         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16385         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16386         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16387         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16388         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16389         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16390         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16391         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16392         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16393         default: printf (_("<unknown: %x>"), bit); break;
16394         }
16395       if (bitmask)
16396         printf (", ");
16397     }
16398 }
16399
16400 static void
16401 decode_x86_feature (unsigned int type, unsigned int bitmask)
16402 {
16403   while (bitmask)
16404     {
16405       unsigned int bit = bitmask & (- bitmask);
16406
16407       bitmask &= ~ bit;
16408       switch (bit)
16409         {
16410         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16411           switch (type)
16412             {
16413             case GNU_PROPERTY_X86_FEATURE_1_AND:
16414               printf ("IBT");
16415               break;
16416             default:
16417               /* This should never happen.  */
16418               abort ();
16419             }
16420           break;
16421         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16422           switch (type)
16423             {
16424             case GNU_PROPERTY_X86_FEATURE_1_AND:
16425               printf ("SHSTK");
16426               break;
16427             default:
16428               /* This should never happen.  */
16429               abort ();
16430             }
16431           break;
16432         default:
16433           printf (_("<unknown: %x>"), bit);
16434           break;
16435         }
16436       if (bitmask)
16437         printf (", ");
16438     }
16439 }
16440
16441 static void
16442 print_gnu_property_note (Elf_Internal_Note * pnote)
16443 {
16444   unsigned char * ptr = (unsigned char *) pnote->descdata;
16445   unsigned char * ptr_end = ptr + pnote->descsz;
16446   unsigned int    size = is_32bit_elf ? 4 : 8;
16447
16448   printf (_("      Properties: "));
16449
16450   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16451     {
16452       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16453       return;
16454     }
16455
16456   while (1)
16457     {
16458       unsigned int j;
16459       unsigned int type = byte_get (ptr, 4);
16460       unsigned int datasz = byte_get (ptr + 4, 4);
16461
16462       ptr += 8;
16463
16464       if ((ptr + datasz) > ptr_end)
16465         {
16466           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16467                   type, datasz);
16468           break;
16469         }
16470
16471       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16472         {
16473           if (elf_header.e_machine == EM_X86_64
16474               || elf_header.e_machine == EM_IAMCU
16475               || elf_header.e_machine == EM_386)
16476             {
16477               switch (type)
16478                 {
16479                 case GNU_PROPERTY_X86_ISA_1_USED:
16480                   printf ("x86 ISA used: ");
16481                   if (datasz != 4)
16482                     printf (_("<corrupt length: %#x> "), datasz);
16483                   else
16484                     decode_x86_isa (byte_get (ptr, 4));
16485                   goto next;
16486
16487                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16488                   printf ("x86 ISA needed: ");
16489                   if (datasz != 4)
16490                     printf (_("<corrupt length: %#x> "), datasz);
16491                   else
16492                     decode_x86_isa (byte_get (ptr, 4));
16493                   goto next;
16494
16495                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16496                   printf ("x86 feature: ");
16497                   if (datasz != 4)
16498                     printf (_("<corrupt length: %#x> "), datasz);
16499                   else
16500                     decode_x86_feature (type, byte_get (ptr, 4));
16501                   goto next;
16502
16503                 default:
16504                   break;
16505                 }
16506             }
16507         }
16508       else
16509         {
16510           switch (type)
16511             {
16512             case GNU_PROPERTY_STACK_SIZE:
16513               printf (_("stack size: "));
16514               if (datasz != size)
16515                 printf (_("<corrupt length: %#x> "), datasz);
16516               else
16517                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16518               goto next;
16519
16520             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16521               printf ("no copy on protected ");
16522               if (datasz)
16523                 printf (_("<corrupt length: %#x> "), datasz);
16524               goto next;
16525
16526             default:
16527               break;
16528             }
16529         }
16530
16531       if (type < GNU_PROPERTY_LOPROC)
16532         printf (_("<unknown type %#x data: "), type);
16533       else if (type < GNU_PROPERTY_LOUSER)
16534         printf (_("<procesor-specific type %#x data: "), type);
16535       else
16536         printf (_("<application-specific type %#x data: "), type);
16537       for (j = 0; j < datasz; ++j)
16538         printf ("%02x ", ptr[j] & 0xff);
16539       printf (">");
16540
16541 next:
16542       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16543       if (ptr == ptr_end)
16544         break;
16545       else
16546         {
16547           if (do_wide)
16548             printf (", ");
16549           else
16550             printf ("\n\t");
16551         }
16552
16553       if (ptr > (ptr_end - 8))
16554         {
16555           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16556           break;
16557         }
16558     }
16559
16560   printf ("\n");
16561 }
16562
16563 static bfd_boolean
16564 print_gnu_note (Elf_Internal_Note *pnote)
16565 {
16566   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16567   switch (pnote->type)
16568     {
16569     case NT_GNU_BUILD_ID:
16570       {
16571         unsigned long i;
16572
16573         printf (_("    Build ID: "));
16574         for (i = 0; i < pnote->descsz; ++i)
16575           printf ("%02x", pnote->descdata[i] & 0xff);
16576         printf ("\n");
16577       }
16578       break;
16579
16580     case NT_GNU_ABI_TAG:
16581       {
16582         unsigned long os, major, minor, subminor;
16583         const char *osname;
16584
16585         /* PR 17531: file: 030-599401-0.004.  */
16586         if (pnote->descsz < 16)
16587           {
16588             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16589             break;
16590           }
16591
16592         os = byte_get ((unsigned char *) pnote->descdata, 4);
16593         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16594         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16595         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16596
16597         switch (os)
16598           {
16599           case GNU_ABI_TAG_LINUX:
16600             osname = "Linux";
16601             break;
16602           case GNU_ABI_TAG_HURD:
16603             osname = "Hurd";
16604             break;
16605           case GNU_ABI_TAG_SOLARIS:
16606             osname = "Solaris";
16607             break;
16608           case GNU_ABI_TAG_FREEBSD:
16609             osname = "FreeBSD";
16610             break;
16611           case GNU_ABI_TAG_NETBSD:
16612             osname = "NetBSD";
16613             break;
16614           case GNU_ABI_TAG_SYLLABLE:
16615             osname = "Syllable";
16616             break;
16617           case GNU_ABI_TAG_NACL:
16618             osname = "NaCl";
16619             break;
16620           default:
16621             osname = "Unknown";
16622             break;
16623           }
16624
16625         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16626                 major, minor, subminor);
16627       }
16628       break;
16629
16630     case NT_GNU_GOLD_VERSION:
16631       {
16632         unsigned long i;
16633
16634         printf (_("    Version: "));
16635         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16636           printf ("%c", pnote->descdata[i]);
16637         printf ("\n");
16638       }
16639       break;
16640
16641     case NT_GNU_HWCAP:
16642       {
16643         unsigned long num_entries, mask;
16644
16645         /* Hardware capabilities information.  Word 0 is the number of entries.
16646            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16647            is a series of entries, where each entry is a single byte followed
16648            by a nul terminated string.  The byte gives the bit number to test
16649            if enabled in the bitmask.  */
16650         printf (_("      Hardware Capabilities: "));
16651         if (pnote->descsz < 8)
16652           {
16653             error (_("<corrupt GNU_HWCAP>\n"));
16654             return FALSE;
16655           }
16656         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16657         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16658         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16659         /* FIXME: Add code to display the entries... */
16660       }
16661       break;
16662
16663     case NT_GNU_PROPERTY_TYPE_0:
16664       print_gnu_property_note (pnote);
16665       break;
16666
16667     default:
16668       /* Handle unrecognised types.  An error message should have already been
16669          created by get_gnu_elf_note_type(), so all that we need to do is to
16670          display the data.  */
16671       {
16672         unsigned long i;
16673
16674         printf (_("    Description data: "));
16675         for (i = 0; i < pnote->descsz; ++i)
16676           printf ("%02x ", pnote->descdata[i] & 0xff);
16677         printf ("\n");
16678       }
16679       break;
16680     }
16681
16682   return TRUE;
16683 }
16684
16685 static const char *
16686 get_v850_elf_note_type (enum v850_notes n_type)
16687 {
16688   static char buff[64];
16689
16690   switch (n_type)
16691     {
16692     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16693     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16694     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16695     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16696     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16697     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16698     default:
16699       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16700       return buff;
16701     }
16702 }
16703
16704 static bfd_boolean
16705 print_v850_note (Elf_Internal_Note * pnote)
16706 {
16707   unsigned int val;
16708
16709   if (pnote->descsz != 4)
16710     return FALSE;
16711
16712   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16713
16714   if (val == 0)
16715     {
16716       printf (_("not set\n"));
16717       return TRUE;
16718     }
16719
16720   switch (pnote->type)
16721     {
16722     case V850_NOTE_ALIGNMENT:
16723       switch (val)
16724         {
16725         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16726         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16727         }
16728       break;
16729
16730     case V850_NOTE_DATA_SIZE:
16731       switch (val)
16732         {
16733         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16734         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16735         }
16736       break;
16737
16738     case V850_NOTE_FPU_INFO:
16739       switch (val)
16740         {
16741         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16742         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16743         }
16744       break;
16745
16746     case V850_NOTE_MMU_INFO:
16747     case V850_NOTE_CACHE_INFO:
16748     case V850_NOTE_SIMD_INFO:
16749       if (val == EF_RH850_SIMD)
16750         {
16751           printf (_("yes\n"));
16752           return TRUE;
16753         }
16754       break;
16755
16756     default:
16757       /* An 'unknown note type' message will already have been displayed.  */
16758       break;
16759     }
16760
16761   printf (_("unknown value: %x\n"), val);
16762   return FALSE;
16763 }
16764
16765 static bfd_boolean
16766 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16767 {
16768   unsigned int version;
16769
16770   switch (pnote->type)
16771     {
16772     case NT_NETBSD_IDENT:
16773       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16774       if ((version / 10000) % 100)
16775         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16776                 version, version / 100000000, (version / 1000000) % 100,
16777                 (version / 10000) % 100 > 26 ? "Z" : "",
16778                 'A' + (version / 10000) % 26);
16779       else
16780         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16781                 version, version / 100000000, (version / 1000000) % 100,
16782                 (version / 100) % 100);
16783       return TRUE;
16784
16785     case NT_NETBSD_MARCH:
16786       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16787               pnote->descdata);
16788       return TRUE;
16789
16790     default:
16791       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16792               pnote->type);
16793       return FALSE;
16794     }
16795 }
16796
16797 static const char *
16798 get_freebsd_elfcore_note_type (unsigned e_type)
16799 {
16800   switch (e_type)
16801     {
16802     case NT_FREEBSD_THRMISC:
16803       return _("NT_THRMISC (thrmisc structure)");
16804     case NT_FREEBSD_PROCSTAT_PROC:
16805       return _("NT_PROCSTAT_PROC (proc data)");
16806     case NT_FREEBSD_PROCSTAT_FILES:
16807       return _("NT_PROCSTAT_FILES (files data)");
16808     case NT_FREEBSD_PROCSTAT_VMMAP:
16809       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16810     case NT_FREEBSD_PROCSTAT_GROUPS:
16811       return _("NT_PROCSTAT_GROUPS (groups data)");
16812     case NT_FREEBSD_PROCSTAT_UMASK:
16813       return _("NT_PROCSTAT_UMASK (umask data)");
16814     case NT_FREEBSD_PROCSTAT_RLIMIT:
16815       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16816     case NT_FREEBSD_PROCSTAT_OSREL:
16817       return _("NT_PROCSTAT_OSREL (osreldate data)");
16818     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16819       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16820     case NT_FREEBSD_PROCSTAT_AUXV:
16821       return _("NT_PROCSTAT_AUXV (auxv data)");
16822     case NT_FREEBSD_PTLWPINFO:
16823       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16824     }
16825   return get_note_type (e_type);
16826 }
16827
16828 static const char *
16829 get_netbsd_elfcore_note_type (unsigned e_type)
16830 {
16831   static char buff[64];
16832
16833   if (e_type == NT_NETBSDCORE_PROCINFO)
16834     {
16835       /* NetBSD core "procinfo" structure.  */
16836       return _("NetBSD procinfo structure");
16837     }
16838
16839   /* As of Jan 2002 there are no other machine-independent notes
16840      defined for NetBSD core files.  If the note type is less
16841      than the start of the machine-dependent note types, we don't
16842      understand it.  */
16843
16844   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16845     {
16846       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16847       return buff;
16848     }
16849
16850   switch (elf_header.e_machine)
16851     {
16852     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16853        and PT_GETFPREGS == mach+2.  */
16854
16855     case EM_OLD_ALPHA:
16856     case EM_ALPHA:
16857     case EM_SPARC:
16858     case EM_SPARC32PLUS:
16859     case EM_SPARCV9:
16860       switch (e_type)
16861         {
16862         case NT_NETBSDCORE_FIRSTMACH + 0:
16863           return _("PT_GETREGS (reg structure)");
16864         case NT_NETBSDCORE_FIRSTMACH + 2:
16865           return _("PT_GETFPREGS (fpreg structure)");
16866         default:
16867           break;
16868         }
16869       break;
16870
16871     /* On all other arch's, PT_GETREGS == mach+1 and
16872        PT_GETFPREGS == mach+3.  */
16873     default:
16874       switch (e_type)
16875         {
16876         case NT_NETBSDCORE_FIRSTMACH + 1:
16877           return _("PT_GETREGS (reg structure)");
16878         case NT_NETBSDCORE_FIRSTMACH + 3:
16879           return _("PT_GETFPREGS (fpreg structure)");
16880         default:
16881           break;
16882         }
16883     }
16884
16885   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16886             e_type - NT_NETBSDCORE_FIRSTMACH);
16887   return buff;
16888 }
16889
16890 static const char *
16891 get_stapsdt_note_type (unsigned e_type)
16892 {
16893   static char buff[64];
16894
16895   switch (e_type)
16896     {
16897     case NT_STAPSDT:
16898       return _("NT_STAPSDT (SystemTap probe descriptors)");
16899
16900     default:
16901       break;
16902     }
16903
16904   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16905   return buff;
16906 }
16907
16908 static bfd_boolean
16909 print_stapsdt_note (Elf_Internal_Note *pnote)
16910 {
16911   int addr_size = is_32bit_elf ? 4 : 8;
16912   char *data = pnote->descdata;
16913   char *data_end = pnote->descdata + pnote->descsz;
16914   bfd_vma pc, base_addr, semaphore;
16915   char *provider, *probe, *arg_fmt;
16916
16917   pc = byte_get ((unsigned char *) data, addr_size);
16918   data += addr_size;
16919   base_addr = byte_get ((unsigned char *) data, addr_size);
16920   data += addr_size;
16921   semaphore = byte_get ((unsigned char *) data, addr_size);
16922   data += addr_size;
16923
16924   provider = data;
16925   data += strlen (data) + 1;
16926   probe = data;
16927   data += strlen (data) + 1;
16928   arg_fmt = data;
16929   data += strlen (data) + 1;
16930
16931   printf (_("    Provider: %s\n"), provider);
16932   printf (_("    Name: %s\n"), probe);
16933   printf (_("    Location: "));
16934   print_vma (pc, FULL_HEX);
16935   printf (_(", Base: "));
16936   print_vma (base_addr, FULL_HEX);
16937   printf (_(", Semaphore: "));
16938   print_vma (semaphore, FULL_HEX);
16939   printf ("\n");
16940   printf (_("    Arguments: %s\n"), arg_fmt);
16941
16942   return data == data_end;
16943 }
16944
16945 static const char *
16946 get_ia64_vms_note_type (unsigned e_type)
16947 {
16948   static char buff[64];
16949
16950   switch (e_type)
16951     {
16952     case NT_VMS_MHD:
16953       return _("NT_VMS_MHD (module header)");
16954     case NT_VMS_LNM:
16955       return _("NT_VMS_LNM (language name)");
16956     case NT_VMS_SRC:
16957       return _("NT_VMS_SRC (source files)");
16958     case NT_VMS_TITLE:
16959       return "NT_VMS_TITLE";
16960     case NT_VMS_EIDC:
16961       return _("NT_VMS_EIDC (consistency check)");
16962     case NT_VMS_FPMODE:
16963       return _("NT_VMS_FPMODE (FP mode)");
16964     case NT_VMS_LINKTIME:
16965       return "NT_VMS_LINKTIME";
16966     case NT_VMS_IMGNAM:
16967       return _("NT_VMS_IMGNAM (image name)");
16968     case NT_VMS_IMGID:
16969       return _("NT_VMS_IMGID (image id)");
16970     case NT_VMS_LINKID:
16971       return _("NT_VMS_LINKID (link id)");
16972     case NT_VMS_IMGBID:
16973       return _("NT_VMS_IMGBID (build id)");
16974     case NT_VMS_GSTNAM:
16975       return _("NT_VMS_GSTNAM (sym table name)");
16976     case NT_VMS_ORIG_DYN:
16977       return "NT_VMS_ORIG_DYN";
16978     case NT_VMS_PATCHTIME:
16979       return "NT_VMS_PATCHTIME";
16980     default:
16981       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16982       return buff;
16983     }
16984 }
16985
16986 static bfd_boolean
16987 print_ia64_vms_note (Elf_Internal_Note * pnote)
16988 {
16989   switch (pnote->type)
16990     {
16991     case NT_VMS_MHD:
16992       if (pnote->descsz > 36)
16993         {
16994           size_t l = strlen (pnote->descdata + 34);
16995           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16996           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16997           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16998           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16999         }
17000       else
17001         printf (_("    Invalid size\n"));
17002       break;
17003     case NT_VMS_LNM:
17004       printf (_("   Language: %s\n"), pnote->descdata);
17005       break;
17006 #ifdef BFD64
17007     case NT_VMS_FPMODE:
17008       printf (_("   Floating Point mode: "));
17009       printf ("0x%016" BFD_VMA_FMT "x\n",
17010               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17011       break;
17012     case NT_VMS_LINKTIME:
17013       printf (_("   Link time: "));
17014       print_vms_time
17015         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17016       printf ("\n");
17017       break;
17018     case NT_VMS_PATCHTIME:
17019       printf (_("   Patch time: "));
17020       print_vms_time
17021         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17022       printf ("\n");
17023       break;
17024     case NT_VMS_ORIG_DYN:
17025       printf (_("   Major id: %u,  minor id: %u\n"),
17026               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17027               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17028       printf (_("   Last modified  : "));
17029       print_vms_time
17030         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17031       printf (_("\n   Link flags  : "));
17032       printf ("0x%016" BFD_VMA_FMT "x\n",
17033               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17034       printf (_("   Header flags: 0x%08x\n"),
17035               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17036       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17037       break;
17038 #endif
17039     case NT_VMS_IMGNAM:
17040       printf (_("    Image name: %s\n"), pnote->descdata);
17041       break;
17042     case NT_VMS_GSTNAM:
17043       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17044       break;
17045     case NT_VMS_IMGID:
17046       printf (_("    Image id: %s\n"), pnote->descdata);
17047       break;
17048     case NT_VMS_LINKID:
17049       printf (_("    Linker id: %s\n"), pnote->descdata);
17050       break;
17051     default:
17052       return FALSE;
17053     }
17054   return TRUE;
17055 }
17056
17057 /* Print the name of the symbol associated with a build attribute
17058    that is attached to address OFFSET.  */
17059
17060 static bfd_boolean
17061 print_symbol_for_build_attribute (FILE *         file,
17062                                   unsigned long  offset,
17063                                   bfd_boolean    is_open_attr)
17064 {
17065   static FILE *             saved_file = NULL;
17066   static char *             strtab;
17067   static unsigned long      strtablen;
17068   static Elf_Internal_Sym * symtab;
17069   static unsigned long      nsyms;
17070   Elf_Internal_Sym *        saved_sym = NULL;
17071   Elf_Internal_Sym *        sym;
17072
17073   if (section_headers != NULL
17074       && (saved_file == NULL || file != saved_file))
17075     {
17076       Elf_Internal_Shdr * symsec;
17077
17078       /* Load the symbol and string sections.  */
17079       for (symsec = section_headers;
17080            symsec < section_headers + elf_header.e_shnum;
17081            symsec ++)
17082         {
17083           if (symsec->sh_type == SHT_SYMTAB)
17084             {
17085               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17086
17087               if (symsec->sh_link < elf_header.e_shnum)
17088                 {
17089                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17090
17091                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17092                                               1, strtab_sec->sh_size,
17093                                               _("string table"));
17094                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17095                 }
17096             }
17097         }
17098       saved_file = file;
17099     }
17100
17101   if (symtab == NULL || strtab == NULL)
17102     {
17103       printf ("\n");
17104       return FALSE;
17105     }
17106
17107   /* Find a symbol whose value matches offset.  */
17108   for (sym = symtab; sym < symtab + nsyms; sym ++)
17109     if (sym->st_value == offset)
17110       {
17111         if (sym->st_name >= strtablen)
17112           /* Huh ?  This should not happen.  */
17113           continue;
17114
17115         if (strtab[sym->st_name] == 0)
17116           continue;
17117
17118         if (is_open_attr)
17119           {
17120             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17121                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17122                FUNC symbols entirely.  */
17123             switch (ELF_ST_TYPE (sym->st_info))
17124               {
17125               case STT_FILE:
17126                 saved_sym = sym;
17127                 /* We can stop searching now.  */
17128                 sym = symtab + nsyms;
17129                 continue;
17130
17131               case STT_OBJECT:
17132                 saved_sym = sym;
17133                 continue;
17134
17135               case STT_FUNC:
17136                 /* Ignore function symbols.  */
17137                 continue;
17138
17139               default:
17140                 break;
17141               }
17142
17143             switch (ELF_ST_BIND (sym->st_info))
17144               {
17145               case STB_GLOBAL:
17146                 if (saved_sym == NULL
17147                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17148                   saved_sym = sym;
17149                 break;
17150
17151               case STB_LOCAL:
17152                 if (saved_sym == NULL)
17153                   saved_sym = sym;
17154                 break;
17155
17156               default:
17157                 break;
17158               }
17159           }
17160         else
17161           {
17162             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17163               continue;
17164
17165             saved_sym = sym;
17166             break;
17167           }
17168       }
17169
17170   printf (" (%s: %s)\n",
17171           is_open_attr ? _("file") : _("func"),
17172           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17173   return TRUE;
17174 }
17175
17176 static bfd_boolean
17177 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17178                                        FILE *              file)
17179 {
17180   static unsigned long global_offset = 0;
17181   unsigned long        offset;
17182   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17183   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17184
17185   if (pnote->descsz == 0)
17186     {
17187       if (is_open_attr)
17188         {
17189           printf (_("    Applies from offset %#lx\n"), global_offset);
17190           return TRUE;
17191         }
17192       else
17193         {
17194           printf (_("    Applies to func at %#lx"), global_offset);
17195           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17196         }
17197     }
17198
17199   if (pnote->descsz != desc_size)
17200     {
17201       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17202       printf (_("    <invalid descsz>"));
17203       return FALSE;
17204     }
17205
17206   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17207
17208   if (is_open_attr)
17209     {
17210       printf (_("    Applies from offset %#lx"), offset);
17211       global_offset = offset;
17212     }
17213   else
17214     {
17215       printf (_("    Applies to func at %#lx"), offset);
17216     }
17217
17218   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17219 }
17220
17221 static bfd_boolean
17222 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17223 {
17224   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17225   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17226   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17227   char         name_type;
17228   char         name_attribute;
17229   const char * expected_types;
17230   const char * name = pnote->namedata;
17231   const char * text;
17232   signed int   left;
17233
17234   if (name == NULL || pnote->namesz < 2)
17235     {
17236       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17237       print_symbol (-20, _("  <corrupt name>"));
17238       return FALSE;
17239     }
17240
17241   left = 20;
17242
17243   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17244   if (name[0] == 'G' && name[1] == 'A')
17245     {
17246       printf ("GA");
17247       name += 2;
17248       left -= 2;
17249     }
17250
17251   switch ((name_type = * name))
17252     {
17253     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17254     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17255     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17256     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17257       printf ("%c", * name);
17258       left --;
17259       break;
17260     default:
17261       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17262       print_symbol (-20, _("<unknown name type>"));
17263       return FALSE;
17264     }
17265
17266   ++ name;
17267   text = NULL;
17268
17269   switch ((name_attribute = * name))
17270     {
17271     case GNU_BUILD_ATTRIBUTE_VERSION:
17272       text = _("<version>");
17273       expected_types = string_expected;
17274       ++ name;
17275       break;
17276     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17277       text = _("<stack prot>");
17278       expected_types = "!+*";
17279       ++ name;
17280       break;
17281     case GNU_BUILD_ATTRIBUTE_RELRO:
17282       text = _("<relro>");
17283       expected_types = bool_expected;
17284       ++ name;
17285       break;
17286     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17287       text = _("<stack size>");
17288       expected_types = number_expected;
17289       ++ name;
17290       break;
17291     case GNU_BUILD_ATTRIBUTE_TOOL:
17292       text = _("<tool>");
17293       expected_types = string_expected;
17294       ++ name;
17295       break;
17296     case GNU_BUILD_ATTRIBUTE_ABI:
17297       text = _("<ABI>");
17298       expected_types = "$*";
17299       ++ name;
17300       break;
17301     case GNU_BUILD_ATTRIBUTE_PIC:
17302       text = _("<PIC>");
17303       expected_types = number_expected;
17304       ++ name;
17305       break;
17306     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17307       text = _("<short enum>");
17308       expected_types = bool_expected;
17309       ++ name;
17310       break;
17311     default:
17312       if (ISPRINT (* name))
17313         {
17314           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17315
17316           if (len > left && ! do_wide)
17317             len = left;
17318           printf ("%.*s:", len, name);
17319           left -= len;
17320           name += len;
17321         }
17322       else
17323         {
17324           static char tmpbuf [128];
17325
17326           error (_("unrecognised byte in name field: %d\n"), * name);
17327           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17328           text = tmpbuf;
17329           name ++;
17330         }
17331       expected_types = "*$!+";
17332       break;
17333     }
17334
17335   if (text)
17336     left -= printf ("%s", text);
17337
17338   if (strchr (expected_types, name_type) == NULL)
17339     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17340
17341   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17342     {
17343       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17344              (unsigned long) pnote->namesz,
17345              (long) (name - pnote->namedata));
17346       return FALSE;
17347     }
17348
17349   if (left < 1 && ! do_wide)
17350     return TRUE;
17351
17352   switch (name_type)
17353     {
17354     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17355       {
17356         unsigned int        bytes;
17357         unsigned long long  val = 0;
17358         unsigned int        shift = 0;
17359         char *              decoded = NULL;
17360
17361         bytes = pnote->namesz - (name - pnote->namedata);
17362         if (bytes > 0)
17363           /* The -1 is because the name field is always 0 terminated, and we
17364              want to be able to ensure that the shift in the while loop below
17365              will not overflow.  */
17366           -- bytes;
17367
17368         if (bytes > sizeof (val))
17369           {
17370             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17371                      pnote->namesz, name, pnote->namedata);
17372             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17373                    bytes);
17374             bytes = sizeof (val);
17375           }
17376         /* We do not bother to warn if bytes == 0 as this can
17377            happen with some early versions of the gcc plugin.  */
17378
17379         while (bytes --)
17380           {
17381             unsigned long byte = (* name ++) & 0xff;
17382
17383             val |= byte << shift;
17384             shift += 8;
17385           }
17386
17387         switch (name_attribute)
17388           {
17389           case GNU_BUILD_ATTRIBUTE_PIC:
17390             switch (val)
17391               {
17392               case 0: decoded = "static"; break;
17393               case 1: decoded = "pic"; break;
17394               case 2: decoded = "PIC"; break;
17395               case 3: decoded = "pie"; break;
17396               case 4: decoded = "PIE"; break;
17397               default: break;
17398               }
17399             break;
17400           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17401             switch (val)
17402               {
17403                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17404               case 0: decoded = "off"; break;
17405               case 1: decoded = "on"; break;
17406               case 2: decoded = "all"; break;
17407               case 3: decoded = "strong"; break;
17408               case 4: decoded = "explicit"; break;
17409               default: break;
17410               }
17411             break;
17412           default:
17413             break;
17414           }
17415
17416         if (decoded != NULL)
17417           {
17418             print_symbol (-left, decoded);
17419             left = 0;
17420           }
17421         else if (val == 0)
17422           {
17423             printf ("0x0");
17424             left -= 3;
17425           }
17426         else
17427           {
17428             if (do_wide)
17429               left -= printf ("0x%llx", val);
17430             else
17431               left -= printf ("0x%-.*llx", left, val);
17432           }
17433       }
17434       break;
17435     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17436       left -= print_symbol (- left, name);
17437       break;
17438     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17439       left -= print_symbol (- left, "true");
17440       break;
17441     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17442       left -= print_symbol (- left, "false");
17443       break;
17444     }
17445
17446   if (do_wide && left > 0)
17447     printf ("%-*s", left, " ");
17448
17449   return TRUE;
17450 }
17451
17452 /* Note that by the ELF standard, the name field is already null byte
17453    terminated, and namesz includes the terminating null byte.
17454    I.E. the value of namesz for the name "FSF" is 4.
17455
17456    If the value of namesz is zero, there is no name present.  */
17457
17458 static bfd_boolean
17459 process_note (Elf_Internal_Note *  pnote,
17460               FILE *               file)
17461 {
17462   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17463   const char * nt;
17464
17465   if (pnote->namesz == 0)
17466     /* If there is no note name, then use the default set of
17467        note type strings.  */
17468     nt = get_note_type (pnote->type);
17469
17470   else if (const_strneq (pnote->namedata, "GNU"))
17471     /* GNU-specific object file notes.  */
17472     nt = get_gnu_elf_note_type (pnote->type);
17473
17474   else if (const_strneq (pnote->namedata, "FreeBSD"))
17475     /* FreeBSD-specific core file notes.  */
17476     nt = get_freebsd_elfcore_note_type (pnote->type);
17477
17478   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17479     /* NetBSD-specific core file notes.  */
17480     nt = get_netbsd_elfcore_note_type (pnote->type);
17481
17482   else if (const_strneq (pnote->namedata, "NetBSD"))
17483     /* NetBSD-specific core file notes.  */
17484     return process_netbsd_elf_note (pnote);
17485
17486   else if (strneq (pnote->namedata, "SPU/", 4))
17487     {
17488       /* SPU-specific core file notes.  */
17489       nt = pnote->namedata + 4;
17490       name = "SPU";
17491     }
17492
17493   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17494     /* VMS/ia64-specific file notes.  */
17495     nt = get_ia64_vms_note_type (pnote->type);
17496
17497   else if (const_strneq (pnote->namedata, "stapsdt"))
17498     nt = get_stapsdt_note_type (pnote->type);
17499
17500   else
17501     /* Don't recognize this note name; just use the default set of
17502        note type strings.  */
17503     nt = get_note_type (pnote->type);
17504
17505   printf ("  ");
17506
17507   if (((const_strneq (pnote->namedata, "GA")
17508         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17509        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17510       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17511           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17512     print_gnu_build_attribute_name (pnote);
17513   else
17514     print_symbol (-20, name);
17515
17516   if (do_wide)
17517     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17518   else
17519     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17520
17521   if (const_strneq (pnote->namedata, "IPF/VMS"))
17522     return print_ia64_vms_note (pnote);
17523   else if (const_strneq (pnote->namedata, "GNU"))
17524     return print_gnu_note (pnote);
17525   else if (const_strneq (pnote->namedata, "stapsdt"))
17526     return print_stapsdt_note (pnote);
17527   else if (const_strneq (pnote->namedata, "CORE"))
17528     return print_core_note (pnote);
17529   else if (((const_strneq (pnote->namedata, "GA")
17530              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17531             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17532            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17533                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17534     return print_gnu_build_attribute_description (pnote, file);
17535
17536   if (pnote->descsz)
17537     {
17538       unsigned long i;
17539
17540       printf (_("   description data: "));
17541       for (i = 0; i < pnote->descsz; i++)
17542         printf ("%02x ", pnote->descdata[i]);
17543       if (!do_wide)
17544         printf ("\n");
17545     }
17546
17547   if (do_wide)
17548     printf ("\n");
17549
17550   return TRUE;
17551 }
17552
17553 static bfd_boolean
17554 process_notes_at (FILE *              file,
17555                   Elf_Internal_Shdr * section,
17556                   bfd_vma             offset,
17557                   bfd_vma             length)
17558 {
17559   Elf_External_Note * pnotes;
17560   Elf_External_Note * external;
17561   char * end;
17562   bfd_boolean res = TRUE;
17563
17564   if (length <= 0)
17565     return FALSE;
17566
17567   if (section)
17568     {
17569       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17570       if (pnotes)
17571         {
17572           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17573             return FALSE;
17574         }
17575     }
17576   else
17577     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17578                                              _("notes"));
17579   if (pnotes == NULL)
17580     return FALSE;
17581
17582   external = pnotes;
17583
17584   if (section)
17585     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17586   else
17587     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17588             (unsigned long) offset, (unsigned long) length);
17589
17590   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17591
17592   end = (char *) pnotes + length;
17593   while ((char *) external < end)
17594     {
17595       Elf_Internal_Note inote;
17596       size_t min_notesz;
17597       char *next;
17598       char * temp = NULL;
17599       size_t data_remaining = end - (char *) external;
17600
17601       if (!is_ia64_vms ())
17602         {
17603           /* PR binutils/15191
17604              Make sure that there is enough data to read.  */
17605           min_notesz = offsetof (Elf_External_Note, name);
17606           if (data_remaining < min_notesz)
17607             {
17608               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17609                     (int) data_remaining);
17610               break;
17611             }
17612           inote.type     = BYTE_GET (external->type);
17613           inote.namesz   = BYTE_GET (external->namesz);
17614           inote.namedata = external->name;
17615           inote.descsz   = BYTE_GET (external->descsz);
17616           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17617           /* PR 17531: file: 3443835e.  */
17618           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17619             {
17620               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17621                     inote.namesz, (long)(end - inote.namedata));
17622               inote.descdata = inote.namedata;
17623               inote.namesz   = 0;
17624             }
17625
17626           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17627           next = inote.descdata + align_power (inote.descsz, 2);
17628         }
17629       else
17630         {
17631           Elf64_External_VMS_Note *vms_external;
17632
17633           /* PR binutils/15191
17634              Make sure that there is enough data to read.  */
17635           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17636           if (data_remaining < min_notesz)
17637             {
17638               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17639                     (int) data_remaining);
17640               break;
17641             }
17642
17643           vms_external = (Elf64_External_VMS_Note *) external;
17644           inote.type     = BYTE_GET (vms_external->type);
17645           inote.namesz   = BYTE_GET (vms_external->namesz);
17646           inote.namedata = vms_external->name;
17647           inote.descsz   = BYTE_GET (vms_external->descsz);
17648           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17649           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17650           next = inote.descdata + align_power (inote.descsz, 3);
17651         }
17652
17653       if (inote.descdata < (char *) external + min_notesz
17654           || next < (char *) external + min_notesz
17655           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17656           || inote.namedata + inote.namesz < inote.namedata
17657           || inote.descdata + inote.descsz < inote.descdata
17658           || data_remaining < (size_t)(next - (char *) external))
17659         {
17660           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17661                 (unsigned long) ((char *) external - (char *) pnotes));
17662           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17663                 inote.type, inote.namesz, inote.descsz);
17664           break;
17665         }
17666
17667       external = (Elf_External_Note *) next;
17668
17669       /* Verify that name is null terminated.  It appears that at least
17670          one version of Linux (RedHat 6.0) generates corefiles that don't
17671          comply with the ELF spec by failing to include the null byte in
17672          namesz.  */
17673       if (inote.namedata[inote.namesz - 1] != '\0')
17674         {
17675           temp = (char *) malloc (inote.namesz + 1);
17676           if (temp == NULL)
17677             {
17678               error (_("Out of memory allocating space for inote name\n"));
17679               res = FALSE;
17680               break;
17681             }
17682
17683           memcpy (temp, inote.namedata, inote.namesz);
17684           temp[inote.namesz] = 0;
17685
17686           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17687           inote.namedata = temp;
17688         }
17689
17690       if (! process_note (& inote, file))
17691         res = FALSE;
17692
17693       if (temp != NULL)
17694         {
17695           free (temp);
17696           temp = NULL;
17697         }
17698     }
17699
17700   free (pnotes);
17701
17702   return res;
17703 }
17704
17705 static bfd_boolean
17706 process_corefile_note_segments (FILE * file)
17707 {
17708   Elf_Internal_Phdr * segment;
17709   unsigned int i;
17710   bfd_boolean res = TRUE;
17711
17712   if (! get_program_headers (file))
17713     return TRUE;
17714
17715   for (i = 0, segment = program_headers;
17716        i < elf_header.e_phnum;
17717        i++, segment++)
17718     {
17719       if (segment->p_type == PT_NOTE)
17720         if (! process_notes_at (file, NULL,
17721                                 (bfd_vma) segment->p_offset,
17722                                 (bfd_vma) segment->p_filesz))
17723           res = FALSE;
17724     }
17725
17726   return res;
17727 }
17728
17729 static bfd_boolean
17730 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17731 {
17732   Elf_External_Note * pnotes;
17733   Elf_External_Note * external;
17734   char * end;
17735   bfd_boolean res = TRUE;
17736
17737   if (length <= 0)
17738     return FALSE;
17739
17740   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17741                                            _("v850 notes"));
17742   if (pnotes == NULL)
17743     return FALSE;
17744
17745   external = pnotes;
17746   end = (char*) pnotes + length;
17747
17748   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17749           (unsigned long) offset, (unsigned long) length);
17750
17751   while ((char *) external + sizeof (Elf_External_Note) < end)
17752     {
17753       Elf_External_Note * next;
17754       Elf_Internal_Note inote;
17755
17756       inote.type     = BYTE_GET (external->type);
17757       inote.namesz   = BYTE_GET (external->namesz);
17758       inote.namedata = external->name;
17759       inote.descsz   = BYTE_GET (external->descsz);
17760       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17761       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17762
17763       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17764         {
17765           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17766           inote.descdata = inote.namedata;
17767           inote.namesz   = 0;
17768         }
17769
17770       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17771
17772       if (   ((char *) next > end)
17773           || ((char *) next <  (char *) pnotes))
17774         {
17775           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17776                 (unsigned long) ((char *) external - (char *) pnotes));
17777           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17778                 inote.type, inote.namesz, inote.descsz);
17779           break;
17780         }
17781
17782       external = next;
17783
17784       /* Prevent out-of-bounds indexing.  */
17785       if (   inote.namedata + inote.namesz > end
17786           || inote.namedata + inote.namesz < inote.namedata)
17787         {
17788           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17789                 (unsigned long) ((char *) external - (char *) pnotes));
17790           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17791                 inote.type, inote.namesz, inote.descsz);
17792           break;
17793         }
17794
17795       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17796
17797       if (! print_v850_note (& inote))
17798         {
17799           res = FALSE;
17800           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17801                   inote.namesz, inote.descsz);
17802         }
17803     }
17804
17805   free (pnotes);
17806
17807   return res;
17808 }
17809
17810 static bfd_boolean
17811 process_note_sections (FILE * file)
17812 {
17813   Elf_Internal_Shdr * section;
17814   unsigned long i;
17815   unsigned int n = 0;
17816   bfd_boolean res = TRUE;
17817
17818   for (i = 0, section = section_headers;
17819        i < elf_header.e_shnum && section != NULL;
17820        i++, section++)
17821     {
17822       if (section->sh_type == SHT_NOTE)
17823         {
17824           if (! process_notes_at (file, section,
17825                                   (bfd_vma) section->sh_offset,
17826                                   (bfd_vma) section->sh_size))
17827             res = FALSE;
17828           n++;
17829         }
17830
17831       if ((   elf_header.e_machine == EM_V800
17832            || elf_header.e_machine == EM_V850
17833            || elf_header.e_machine == EM_CYGNUS_V850)
17834           && section->sh_type == SHT_RENESAS_INFO)
17835         {
17836           if (! process_v850_notes (file,
17837                                     (bfd_vma) section->sh_offset,
17838                                     (bfd_vma) section->sh_size))
17839             res = FALSE;
17840           n++;
17841         }
17842     }
17843
17844   if (n == 0)
17845     /* Try processing NOTE segments instead.  */
17846     return process_corefile_note_segments (file);
17847
17848   return res;
17849 }
17850
17851 static bfd_boolean
17852 process_notes (FILE * file)
17853 {
17854   /* If we have not been asked to display the notes then do nothing.  */
17855   if (! do_notes)
17856     return TRUE;
17857
17858   if (elf_header.e_type != ET_CORE)
17859     return process_note_sections (file);
17860
17861   /* No program headers means no NOTE segment.  */
17862   if (elf_header.e_phnum > 0)
17863     return process_corefile_note_segments (file);
17864
17865   printf (_("No note segments present in the core file.\n"));
17866   return TRUE;
17867 }
17868
17869 static unsigned char *
17870 display_public_gnu_attributes (unsigned char * start,
17871                                const unsigned char * const end)
17872 {
17873   printf (_("  Unknown GNU attribute: %s\n"), start);
17874
17875   start += strnlen ((char *) start, end - start);
17876   display_raw_attribute (start, end);
17877
17878   return (unsigned char *) end;
17879 }
17880
17881 static unsigned char *
17882 display_generic_attribute (unsigned char * start,
17883                            unsigned int tag,
17884                            const unsigned char * const end)
17885 {
17886   if (tag == 0)
17887     return (unsigned char *) end;
17888
17889   return display_tag_value (tag, start, end);
17890 }
17891
17892 static bfd_boolean
17893 process_arch_specific (FILE * file)
17894 {
17895   if (! do_arch)
17896     return TRUE;
17897
17898   switch (elf_header.e_machine)
17899     {
17900     case EM_ARC:
17901     case EM_ARC_COMPACT:
17902     case EM_ARC_COMPACT2:
17903       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17904                                  display_arc_attribute,
17905                                  display_generic_attribute);
17906     case EM_ARM:
17907       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17908                                  display_arm_attribute,
17909                                  display_generic_attribute);
17910
17911     case EM_MIPS:
17912     case EM_MIPS_RS3_LE:
17913       return process_mips_specific (file);
17914
17915     case EM_MSP430:
17916      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17917                                  display_msp430x_attribute,
17918                                  display_generic_attribute);
17919
17920     case EM_NDS32:
17921       return process_nds32_specific (file);
17922
17923     case EM_PPC:
17924     case EM_PPC64:
17925       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17926                                  display_power_gnu_attribute);
17927
17928     case EM_S390:
17929     case EM_S390_OLD:
17930       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17931                                  display_s390_gnu_attribute);
17932
17933     case EM_SPARC:
17934     case EM_SPARC32PLUS:
17935     case EM_SPARCV9:
17936       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17937                                  display_sparc_gnu_attribute);
17938
17939     case EM_TI_C6000:
17940       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17941                                  display_tic6x_attribute,
17942                                  display_generic_attribute);
17943
17944     default:
17945       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17946                                  display_public_gnu_attributes,
17947                                  display_generic_attribute);
17948     }
17949 }
17950
17951 static bfd_boolean
17952 get_file_header (FILE * file)
17953 {
17954   /* Read in the identity array.  */
17955   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17956     return FALSE;
17957
17958   /* Determine how to read the rest of the header.  */
17959   switch (elf_header.e_ident[EI_DATA])
17960     {
17961     default:
17962     case ELFDATANONE:
17963     case ELFDATA2LSB:
17964       byte_get = byte_get_little_endian;
17965       byte_put = byte_put_little_endian;
17966       break;
17967     case ELFDATA2MSB:
17968       byte_get = byte_get_big_endian;
17969       byte_put = byte_put_big_endian;
17970       break;
17971     }
17972
17973   /* For now we only support 32 bit and 64 bit ELF files.  */
17974   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17975
17976   /* Read in the rest of the header.  */
17977   if (is_32bit_elf)
17978     {
17979       Elf32_External_Ehdr ehdr32;
17980
17981       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17982         return FALSE;
17983
17984       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17985       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17986       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17987       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17988       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17989       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17990       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17991       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17992       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17993       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17994       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17995       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17996       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17997     }
17998   else
17999     {
18000       Elf64_External_Ehdr ehdr64;
18001
18002       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18003          we will not be able to cope with the 64bit data found in
18004          64 ELF files.  Detect this now and abort before we start
18005          overwriting things.  */
18006       if (sizeof (bfd_vma) < 8)
18007         {
18008           error (_("This instance of readelf has been built without support for a\n\
18009 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18010           return FALSE;
18011         }
18012
18013       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18014         return FALSE;
18015
18016       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
18017       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18018       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
18019       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18020       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18021       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18022       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18023       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18024       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18025       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18026       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18027       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18028       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18029     }
18030
18031   if (elf_header.e_shoff)
18032     {
18033       /* There may be some extensions in the first section header.  Don't
18034          bomb if we can't read it.  */
18035       if (is_32bit_elf)
18036         get_32bit_section_headers (file, TRUE);
18037       else
18038         get_64bit_section_headers (file, TRUE);
18039     }
18040
18041   return TRUE;
18042 }
18043
18044 /* Process one ELF object file according to the command line options.
18045    This file may actually be stored in an archive.  The file is
18046    positioned at the start of the ELF object.  Returns TRUE if no
18047    problems were encountered, FALSE otherwise.  */
18048
18049 static bfd_boolean
18050 process_object (char * file_name, FILE * file)
18051 {
18052   unsigned int i;
18053   bfd_boolean res = TRUE;
18054
18055   if (! get_file_header (file))
18056     {
18057       error (_("%s: Failed to read file header\n"), file_name);
18058       return FALSE;
18059     }
18060
18061   /* Initialise per file variables.  */
18062   for (i = ARRAY_SIZE (version_info); i--;)
18063     version_info[i] = 0;
18064
18065   for (i = ARRAY_SIZE (dynamic_info); i--;)
18066     dynamic_info[i] = 0;
18067   dynamic_info_DT_GNU_HASH = 0;
18068
18069   /* Process the file.  */
18070   if (show_name)
18071     printf (_("\nFile: %s\n"), file_name);
18072
18073   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18074      Note we do this even if cmdline_dump_sects is empty because we
18075      must make sure that the dump_sets array is zeroed out before each
18076      object file is processed.  */
18077   if (num_dump_sects > num_cmdline_dump_sects)
18078     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18079
18080   if (num_cmdline_dump_sects > 0)
18081     {
18082       if (num_dump_sects == 0)
18083         /* A sneaky way of allocating the dump_sects array.  */
18084         request_dump_bynumber (num_cmdline_dump_sects, 0);
18085
18086       assert (num_dump_sects >= num_cmdline_dump_sects);
18087       memcpy (dump_sects, cmdline_dump_sects,
18088               num_cmdline_dump_sects * sizeof (* dump_sects));
18089     }
18090
18091   if (! process_file_header ())
18092     return FALSE;
18093
18094   if (! process_section_headers (file))
18095     {
18096       /* Without loaded section headers we cannot process lots of things.  */
18097       do_unwind = do_version = do_dump = do_arch = FALSE;
18098
18099       if (! do_using_dynamic)
18100         do_syms = do_dyn_syms = do_reloc = FALSE;
18101     }
18102
18103   if (! process_section_groups (file))
18104     /* Without loaded section groups we cannot process unwind.  */
18105     do_unwind = FALSE;
18106
18107   if (process_program_headers (file))
18108     process_dynamic_section (file);
18109   else
18110     res = FALSE;
18111
18112   if (! process_relocs (file))
18113     res = FALSE;
18114
18115   if (! process_unwind (file))
18116     res = FALSE;
18117
18118   if (! process_symbol_table (file))
18119     res = FALSE;
18120
18121   if (! process_syminfo (file))
18122     res = FALSE;
18123
18124   if (! process_version_sections (file))
18125     res = FALSE;
18126
18127   if (! process_section_contents (file))
18128     res = FALSE;
18129
18130   if (! process_notes (file))
18131     res = FALSE;
18132
18133   if (! process_gnu_liblist (file))
18134     res = FALSE;
18135
18136   if (! process_arch_specific (file))
18137     res = FALSE;
18138
18139   if (program_headers)
18140     {
18141       free (program_headers);
18142       program_headers = NULL;
18143     }
18144
18145   if (section_headers)
18146     {
18147       free (section_headers);
18148       section_headers = NULL;
18149     }
18150
18151   if (string_table)
18152     {
18153       free (string_table);
18154       string_table = NULL;
18155       string_table_length = 0;
18156     }
18157
18158   if (dynamic_strings)
18159     {
18160       free (dynamic_strings);
18161       dynamic_strings = NULL;
18162       dynamic_strings_length = 0;
18163     }
18164
18165   if (dynamic_symbols)
18166     {
18167       free (dynamic_symbols);
18168       dynamic_symbols = NULL;
18169       num_dynamic_syms = 0;
18170     }
18171
18172   if (dynamic_syminfo)
18173     {
18174       free (dynamic_syminfo);
18175       dynamic_syminfo = NULL;
18176     }
18177
18178   if (dynamic_section)
18179     {
18180       free (dynamic_section);
18181       dynamic_section = NULL;
18182     }
18183
18184   if (section_headers_groups)
18185     {
18186       free (section_headers_groups);
18187       section_headers_groups = NULL;
18188     }
18189
18190   if (section_groups)
18191     {
18192       struct group_list * g;
18193       struct group_list * next;
18194
18195       for (i = 0; i < group_count; i++)
18196         {
18197           for (g = section_groups [i].root; g != NULL; g = next)
18198             {
18199               next = g->next;
18200               free (g);
18201             }
18202         }
18203
18204       free (section_groups);
18205       section_groups = NULL;
18206     }
18207
18208   free_debug_memory ();
18209
18210   return res;
18211 }
18212
18213 /* Process an ELF archive.
18214    On entry the file is positioned just after the ARMAG string.
18215    Returns TRUE upon success, FALSE otherwise.  */
18216
18217 static bfd_boolean
18218 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18219 {
18220   struct archive_info arch;
18221   struct archive_info nested_arch;
18222   size_t got;
18223   bfd_boolean ret = TRUE;
18224
18225   show_name = TRUE;
18226
18227   /* The ARCH structure is used to hold information about this archive.  */
18228   arch.file_name = NULL;
18229   arch.file = NULL;
18230   arch.index_array = NULL;
18231   arch.sym_table = NULL;
18232   arch.longnames = NULL;
18233
18234   /* The NESTED_ARCH structure is used as a single-item cache of information
18235      about a nested archive (when members of a thin archive reside within
18236      another regular archive file).  */
18237   nested_arch.file_name = NULL;
18238   nested_arch.file = NULL;
18239   nested_arch.index_array = NULL;
18240   nested_arch.sym_table = NULL;
18241   nested_arch.longnames = NULL;
18242
18243   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18244     {
18245       ret = FALSE;
18246       goto out;
18247     }
18248
18249   if (do_archive_index)
18250     {
18251       if (arch.sym_table == NULL)
18252         error (_("%s: unable to dump the index as none was found\n"), file_name);
18253       else
18254         {
18255           unsigned long i, l;
18256           unsigned long current_pos;
18257
18258           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18259                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18260           current_pos = ftell (file);
18261
18262           for (i = l = 0; i < arch.index_num; i++)
18263             {
18264               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18265                 {
18266                   char * member_name;
18267
18268                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18269
18270                   if (member_name != NULL)
18271                     {
18272                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18273
18274                       if (qualified_name != NULL)
18275                         {
18276                           printf (_("Contents of binary %s at offset "), qualified_name);
18277                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18278                           putchar ('\n');
18279                           free (qualified_name);
18280                         }
18281                     }
18282                 }
18283
18284               if (l >= arch.sym_size)
18285                 {
18286                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18287                          file_name);
18288                   ret = FALSE;
18289                   break;
18290                 }
18291               /* PR 17531: file: 0b6630b2.  */
18292               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18293               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18294             }
18295
18296           if (arch.uses_64bit_indicies)
18297             l = (l + 7) & ~ 7;
18298           else
18299             l += l & 1;
18300
18301           if (l < arch.sym_size)
18302             {
18303               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18304                      file_name, arch.sym_size - l);
18305               ret = FALSE;
18306             }
18307
18308           if (fseek (file, current_pos, SEEK_SET) != 0)
18309             {
18310               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18311               ret = FALSE;
18312               goto out;
18313             }
18314         }
18315
18316       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18317           && !do_segments && !do_header && !do_dump && !do_version
18318           && !do_histogram && !do_debugging && !do_arch && !do_notes
18319           && !do_section_groups && !do_dyn_syms)
18320         {
18321           ret = TRUE; /* Archive index only.  */
18322           goto out;
18323         }
18324     }
18325
18326   while (1)
18327     {
18328       char * name;
18329       size_t namelen;
18330       char * qualified_name;
18331
18332       /* Read the next archive header.  */
18333       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18334         {
18335           error (_("%s: failed to seek to next archive header\n"), file_name);
18336           return FALSE;
18337         }
18338       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18339       if (got != sizeof arch.arhdr)
18340         {
18341           if (got == 0)
18342             break;
18343           error (_("%s: failed to read archive header\n"), file_name);
18344           ret = FALSE;
18345           break;
18346         }
18347       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18348         {
18349           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18350           ret = FALSE;
18351           break;
18352         }
18353
18354       arch.next_arhdr_offset += sizeof arch.arhdr;
18355
18356       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18357       if (archive_file_size & 01)
18358         ++archive_file_size;
18359
18360       name = get_archive_member_name (&arch, &nested_arch);
18361       if (name == NULL)
18362         {
18363           error (_("%s: bad archive file name\n"), file_name);
18364           ret = FALSE;
18365           break;
18366         }
18367       namelen = strlen (name);
18368
18369       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18370       if (qualified_name == NULL)
18371         {
18372           error (_("%s: bad archive file name\n"), file_name);
18373           ret = FALSE;
18374           break;
18375         }
18376
18377       if (is_thin_archive && arch.nested_member_origin == 0)
18378         {
18379           /* This is a proxy for an external member of a thin archive.  */
18380           FILE * member_file;
18381           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18382
18383           if (member_file_name == NULL)
18384             {
18385               ret = FALSE;
18386               break;
18387             }
18388
18389           member_file = fopen (member_file_name, "rb");
18390           if (member_file == NULL)
18391             {
18392               error (_("Input file '%s' is not readable.\n"), member_file_name);
18393               free (member_file_name);
18394               ret = FALSE;
18395               break;
18396             }
18397
18398           archive_file_offset = arch.nested_member_origin;
18399
18400           if (! process_object (qualified_name, member_file))
18401             ret = FALSE;
18402
18403           fclose (member_file);
18404           free (member_file_name);
18405         }
18406       else if (is_thin_archive)
18407         {
18408           /* PR 15140: Allow for corrupt thin archives.  */
18409           if (nested_arch.file == NULL)
18410             {
18411               error (_("%s: contains corrupt thin archive: %s\n"),
18412                      file_name, name);
18413               ret = FALSE;
18414               break;
18415             }
18416
18417           /* This is a proxy for a member of a nested archive.  */
18418           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18419
18420           /* The nested archive file will have been opened and setup by
18421              get_archive_member_name.  */
18422           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18423             {
18424               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18425               ret = FALSE;
18426               break;
18427             }
18428
18429           if (! process_object (qualified_name, nested_arch.file))
18430             ret = FALSE;
18431         }
18432       else
18433         {
18434           archive_file_offset = arch.next_arhdr_offset;
18435           arch.next_arhdr_offset += archive_file_size;
18436
18437           if (! process_object (qualified_name, file))
18438             ret = FALSE;
18439         }
18440
18441       if (dump_sects != NULL)
18442         {
18443           free (dump_sects);
18444           dump_sects = NULL;
18445           num_dump_sects = 0;
18446         }
18447
18448       free (qualified_name);
18449     }
18450
18451  out:
18452   if (nested_arch.file != NULL)
18453     fclose (nested_arch.file);
18454   release_archive (&nested_arch);
18455   release_archive (&arch);
18456
18457   return ret;
18458 }
18459
18460 static bfd_boolean
18461 process_file (char * file_name)
18462 {
18463   FILE * file;
18464   struct stat statbuf;
18465   char armag[SARMAG];
18466   bfd_boolean ret = TRUE;
18467
18468   if (stat (file_name, &statbuf) < 0)
18469     {
18470       if (errno == ENOENT)
18471         error (_("'%s': No such file\n"), file_name);
18472       else
18473         error (_("Could not locate '%s'.  System error message: %s\n"),
18474                file_name, strerror (errno));
18475       return FALSE;
18476     }
18477
18478   if (! S_ISREG (statbuf.st_mode))
18479     {
18480       error (_("'%s' is not an ordinary file\n"), file_name);
18481       return FALSE;
18482     }
18483
18484   file = fopen (file_name, "rb");
18485   if (file == NULL)
18486     {
18487       error (_("Input file '%s' is not readable.\n"), file_name);
18488       return FALSE;
18489     }
18490
18491   if (fread (armag, SARMAG, 1, file) != 1)
18492     {
18493       error (_("%s: Failed to read file's magic number\n"), file_name);
18494       fclose (file);
18495       return FALSE;
18496     }
18497
18498   current_file_size = (bfd_size_type) statbuf.st_size;
18499
18500   if (memcmp (armag, ARMAG, SARMAG) == 0)
18501     {
18502       if (! process_archive (file_name, file, FALSE))
18503         ret = FALSE;
18504     }
18505   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18506     {
18507       if ( ! process_archive (file_name, file, TRUE))
18508         ret = FALSE;
18509     }
18510   else
18511     {
18512       if (do_archive_index)
18513         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18514                file_name);
18515
18516       rewind (file);
18517       archive_file_size = archive_file_offset = 0;
18518
18519       if (! process_object (file_name, file))
18520         ret = FALSE;
18521     }
18522
18523   fclose (file);
18524   current_file_size = 0;
18525
18526   return ret;
18527 }
18528
18529 #ifdef SUPPORT_DISASSEMBLY
18530 /* Needed by the i386 disassembler.  For extra credit, someone could
18531    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18532    symbols.  */
18533
18534 void
18535 print_address (unsigned int addr, FILE * outfile)
18536 {
18537   fprintf (outfile,"0x%8.8x", addr);
18538 }
18539
18540 /* Needed by the i386 disassembler.  */
18541 void
18542 db_task_printsym (unsigned int addr)
18543 {
18544   print_address (addr, stderr);
18545 }
18546 #endif
18547
18548 int
18549 main (int argc, char ** argv)
18550 {
18551   int err;
18552
18553 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18554   setlocale (LC_MESSAGES, "");
18555 #endif
18556 #if defined (HAVE_SETLOCALE)
18557   setlocale (LC_CTYPE, "");
18558 #endif
18559   bindtextdomain (PACKAGE, LOCALEDIR);
18560   textdomain (PACKAGE);
18561
18562   expandargv (&argc, &argv);
18563
18564   parse_args (argc, argv);
18565
18566   if (num_dump_sects > 0)
18567     {
18568       /* Make a copy of the dump_sects array.  */
18569       cmdline_dump_sects = (dump_type *)
18570           malloc (num_dump_sects * sizeof (* dump_sects));
18571       if (cmdline_dump_sects == NULL)
18572         error (_("Out of memory allocating dump request table.\n"));
18573       else
18574         {
18575           memcpy (cmdline_dump_sects, dump_sects,
18576                   num_dump_sects * sizeof (* dump_sects));
18577           num_cmdline_dump_sects = num_dump_sects;
18578         }
18579     }
18580
18581   if (optind < (argc - 1))
18582     show_name = TRUE;
18583   else if (optind >= argc)
18584     {
18585       warn (_("Nothing to do.\n"));
18586       usage (stderr);
18587     }
18588
18589   err = FALSE;
18590   while (optind < argc)
18591     if (! process_file (argv[optind++]))
18592       err = TRUE;
18593
18594   if (dump_sects != NULL)
18595     free (dump_sects);
18596   if (cmdline_dump_sects != NULL)
18597     free (cmdline_dump_sects);
18598
18599   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18600 }