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 == 54; /* R_SPARC_UA64.  */
12300     case EM_X86_64:
12301     case EM_L1OM:
12302     case EM_K1OM:
12303       return reloc_type == 1; /* R_X86_64_64.  */
12304     case EM_S390_OLD:
12305     case EM_S390:
12306       return reloc_type == 22;  /* R_S390_64.  */
12307     case EM_TILEGX:
12308       return reloc_type == 1; /* R_TILEGX_64.  */
12309     case EM_MIPS:
12310       return reloc_type == 18;  /* R_MIPS_64.  */
12311     default:
12312       return FALSE;
12313     }
12314 }
12315
12316 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12317    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12318
12319 static bfd_boolean
12320 is_64bit_pcrel_reloc (unsigned int reloc_type)
12321 {
12322   switch (elf_header.e_machine)
12323     {
12324     case EM_AARCH64:
12325       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12326     case EM_ALPHA:
12327       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12328     case EM_IA_64:
12329       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12330               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12331     case EM_PARISC:
12332       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12333     case EM_PPC64:
12334       return reloc_type == 44; /* R_PPC64_REL64.  */
12335     case EM_SPARC32PLUS:
12336     case EM_SPARCV9:
12337     case EM_SPARC:
12338       return reloc_type == 46; /* R_SPARC_DISP64.  */
12339     case EM_X86_64:
12340     case EM_L1OM:
12341     case EM_K1OM:
12342       return reloc_type == 24; /* R_X86_64_PC64.  */
12343     case EM_S390_OLD:
12344     case EM_S390:
12345       return reloc_type == 23;  /* R_S390_PC64.  */
12346     case EM_TILEGX:
12347       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12348     default:
12349       return FALSE;
12350     }
12351 }
12352
12353 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12354    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12355
12356 static bfd_boolean
12357 is_24bit_abs_reloc (unsigned int reloc_type)
12358 {
12359   switch (elf_header.e_machine)
12360     {
12361     case EM_CYGNUS_MN10200:
12362     case EM_MN10200:
12363       return reloc_type == 4; /* R_MN10200_24.  */
12364     case EM_FT32:
12365       return reloc_type == 5; /* R_FT32_20.  */
12366     default:
12367       return FALSE;
12368     }
12369 }
12370
12371 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12372    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12373
12374 static bfd_boolean
12375 is_16bit_abs_reloc (unsigned int reloc_type)
12376 {
12377   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12378   switch (elf_header.e_machine)
12379     {
12380     case EM_ARC:
12381     case EM_ARC_COMPACT:
12382     case EM_ARC_COMPACT2:
12383       return reloc_type == 2; /* R_ARC_16.  */
12384     case EM_ADAPTEVA_EPIPHANY:
12385       return reloc_type == 5;
12386     case EM_AVR_OLD:
12387     case EM_AVR:
12388       return reloc_type == 4; /* R_AVR_16.  */
12389     case EM_CYGNUS_D10V:
12390     case EM_D10V:
12391       return reloc_type == 3; /* R_D10V_16.  */
12392     case EM_H8S:
12393     case EM_H8_300:
12394     case EM_H8_300H:
12395       return reloc_type == R_H8_DIR16;
12396     case EM_IP2K_OLD:
12397     case EM_IP2K:
12398       return reloc_type == 1; /* R_IP2K_16.  */
12399     case EM_M32C_OLD:
12400     case EM_M32C:
12401       return reloc_type == 1; /* R_M32C_16 */
12402     case EM_CYGNUS_MN10200:
12403     case EM_MN10200:
12404       return reloc_type == 2; /* R_MN10200_16.  */
12405     case EM_CYGNUS_MN10300:
12406     case EM_MN10300:
12407       return reloc_type == 2; /* R_MN10300_16.  */
12408     case EM_MSP430:
12409       if (uses_msp430x_relocs ())
12410         return reloc_type == 2; /* R_MSP430_ABS16.  */
12411       /* Fall through.  */
12412     case EM_MSP430_OLD:
12413       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12414     case EM_NDS32:
12415       return reloc_type == 19; /* R_NDS32_RELA.  */
12416     case EM_ALTERA_NIOS2:
12417       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12418     case EM_NIOS32:
12419       return reloc_type == 9; /* R_NIOS_16.  */
12420     case EM_OR1K:
12421       return reloc_type == 2; /* R_OR1K_16.  */
12422     case EM_TI_PRU:
12423       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12424     case EM_TI_C6000:
12425       return reloc_type == 2; /* R_C6000_ABS16.  */
12426     case EM_VISIUM:
12427       return reloc_type == 2; /* R_VISIUM_16. */
12428     case EM_XC16X:
12429     case EM_C166:
12430       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12431     case EM_XGATE:
12432       return reloc_type == 3; /* R_XGATE_16.  */
12433     default:
12434       return FALSE;
12435     }
12436 }
12437
12438 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12439    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12440
12441 static bfd_boolean
12442 is_none_reloc (unsigned int reloc_type)
12443 {
12444   switch (elf_header.e_machine)
12445     {
12446     case EM_386:     /* R_386_NONE.  */
12447     case EM_68K:     /* R_68K_NONE.  */
12448     case EM_ADAPTEVA_EPIPHANY:
12449     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12450     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12451     case EM_ARC:     /* R_ARC_NONE.  */
12452     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12453     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12454     case EM_ARM:     /* R_ARM_NONE.  */
12455     case EM_C166:    /* R_XC16X_NONE.  */
12456     case EM_CRIS:    /* R_CRIS_NONE.  */
12457     case EM_FT32:    /* R_FT32_NONE.  */
12458     case EM_IA_64:   /* R_IA64_NONE.  */
12459     case EM_K1OM:    /* R_X86_64_NONE.  */
12460     case EM_L1OM:    /* R_X86_64_NONE.  */
12461     case EM_M32R:    /* R_M32R_NONE.  */
12462     case EM_MIPS:    /* R_MIPS_NONE.  */
12463     case EM_MN10300: /* R_MN10300_NONE.  */
12464     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12465     case EM_NIOS32:  /* R_NIOS_NONE.  */
12466     case EM_OR1K:    /* R_OR1K_NONE. */
12467     case EM_PARISC:  /* R_PARISC_NONE.  */
12468     case EM_PPC64:   /* R_PPC64_NONE.  */
12469     case EM_PPC:     /* R_PPC_NONE.  */
12470     case EM_RISCV:   /* R_RISCV_NONE.  */
12471     case EM_S390:    /* R_390_NONE.  */
12472     case EM_S390_OLD:
12473     case EM_SH:      /* R_SH_NONE.  */
12474     case EM_SPARC32PLUS:
12475     case EM_SPARC:   /* R_SPARC_NONE.  */
12476     case EM_SPARCV9:
12477     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12478     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12479     case EM_TI_C6000:/* R_C6000_NONE.  */
12480     case EM_X86_64:  /* R_X86_64_NONE.  */
12481     case EM_XC16X:
12482     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12483       return reloc_type == 0;
12484
12485     case EM_AARCH64:
12486       return reloc_type == 0 || reloc_type == 256;
12487     case EM_AVR_OLD:
12488     case EM_AVR:
12489       return (reloc_type == 0 /* R_AVR_NONE.  */
12490               || reloc_type == 30 /* R_AVR_DIFF8.  */
12491               || reloc_type == 31 /* R_AVR_DIFF16.  */
12492               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12493     case EM_METAG:
12494       return reloc_type == 3; /* R_METAG_NONE.  */
12495     case EM_NDS32:
12496       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12497               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12498               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12499               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12500               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12501     case EM_TI_PRU:
12502       return (reloc_type == 0       /* R_PRU_NONE.  */
12503               || reloc_type == 65   /* R_PRU_DIFF8.  */
12504               || reloc_type == 66   /* R_PRU_DIFF16.  */
12505               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12506     case EM_XTENSA_OLD:
12507     case EM_XTENSA:
12508       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12509               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12510               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12511               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12512     }
12513   return FALSE;
12514 }
12515
12516 /* Returns TRUE if there is a relocation against
12517    section NAME at OFFSET bytes.  */
12518
12519 bfd_boolean
12520 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12521 {
12522   Elf_Internal_Rela * relocs;
12523   Elf_Internal_Rela * rp;
12524
12525   if (dsec == NULL || dsec->reloc_info == NULL)
12526     return FALSE;
12527
12528   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12529
12530   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12531     if (rp->r_offset == offset)
12532       return TRUE;
12533
12534    return FALSE;
12535 }
12536
12537 /* Apply relocations to a section.
12538    Returns TRUE upon success, FALSE otherwise.
12539    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12540    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12541    will be set to the number of relocs loaded.
12542
12543    Note: So far support has been added only for those relocations
12544    which can be found in debug sections. FIXME: Add support for
12545    more relocations ?  */
12546
12547 static bfd_boolean
12548 apply_relocations (void *                     file,
12549                    const Elf_Internal_Shdr *  section,
12550                    unsigned char *            start,
12551                    bfd_size_type              size,
12552                    void **                    relocs_return,
12553                    unsigned long *            num_relocs_return)
12554 {
12555   Elf_Internal_Shdr * relsec;
12556   unsigned char * end = start + size;
12557   bfd_boolean res = TRUE;
12558
12559   if (relocs_return != NULL)
12560     {
12561       * (Elf_Internal_Rela **) relocs_return = NULL;
12562       * num_relocs_return = 0;
12563     }
12564
12565   if (elf_header.e_type != ET_REL)
12566     /* No relocs to apply.  */
12567     return TRUE;
12568
12569   /* Find the reloc section associated with the section.  */
12570   for (relsec = section_headers;
12571        relsec < section_headers + elf_header.e_shnum;
12572        ++relsec)
12573     {
12574       bfd_boolean is_rela;
12575       unsigned long num_relocs;
12576       Elf_Internal_Rela * relocs;
12577       Elf_Internal_Rela * rp;
12578       Elf_Internal_Shdr * symsec;
12579       Elf_Internal_Sym * symtab;
12580       unsigned long num_syms;
12581       Elf_Internal_Sym * sym;
12582
12583       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12584           || relsec->sh_info >= elf_header.e_shnum
12585           || section_headers + relsec->sh_info != section
12586           || relsec->sh_size == 0
12587           || relsec->sh_link >= elf_header.e_shnum)
12588         continue;
12589
12590       is_rela = relsec->sh_type == SHT_RELA;
12591
12592       if (is_rela)
12593         {
12594           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12595                                   relsec->sh_size, & relocs, & num_relocs))
12596             return FALSE;
12597         }
12598       else
12599         {
12600           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12601                                  relsec->sh_size, & relocs, & num_relocs))
12602             return FALSE;
12603         }
12604
12605       /* SH uses RELA but uses in place value instead of the addend field.  */
12606       if (elf_header.e_machine == EM_SH)
12607         is_rela = FALSE;
12608
12609       symsec = section_headers + relsec->sh_link;
12610       if (symsec->sh_type != SHT_SYMTAB
12611           && symsec->sh_type != SHT_DYNSYM)
12612         return FALSE;
12613       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12614
12615       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12616         {
12617           bfd_vma         addend;
12618           unsigned int    reloc_type;
12619           unsigned int    reloc_size;
12620           unsigned char * rloc;
12621           unsigned long   sym_index;
12622
12623           reloc_type = get_reloc_type (rp->r_info);
12624
12625           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12626             continue;
12627           else if (is_none_reloc (reloc_type))
12628             continue;
12629           else if (is_32bit_abs_reloc (reloc_type)
12630                    || is_32bit_pcrel_reloc (reloc_type))
12631             reloc_size = 4;
12632           else if (is_64bit_abs_reloc (reloc_type)
12633                    || is_64bit_pcrel_reloc (reloc_type))
12634             reloc_size = 8;
12635           else if (is_24bit_abs_reloc (reloc_type))
12636             reloc_size = 3;
12637           else if (is_16bit_abs_reloc (reloc_type))
12638             reloc_size = 2;
12639           else
12640             {
12641               static unsigned int prev_reloc = 0;
12642               if (reloc_type != prev_reloc)
12643                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12644                       reloc_type, printable_section_name (section));
12645               prev_reloc = reloc_type;
12646               res = FALSE;
12647               continue;
12648             }
12649
12650           rloc = start + rp->r_offset;
12651           if ((rloc + reloc_size) > end || (rloc < start))
12652             {
12653               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12654                     (unsigned long) rp->r_offset,
12655                     printable_section_name (section));
12656               res = FALSE;
12657               continue;
12658             }
12659
12660           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12661           if (sym_index >= num_syms)
12662             {
12663               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12664                     sym_index, printable_section_name (section));
12665               res = FALSE;
12666               continue;
12667             }
12668           sym = symtab + sym_index;
12669
12670           /* If the reloc has a symbol associated with it,
12671              make sure that it is of an appropriate type.
12672
12673              Relocations against symbols without type can happen.
12674              Gcc -feliminate-dwarf2-dups may generate symbols
12675              without type for debug info.
12676
12677              Icc generates relocations against function symbols
12678              instead of local labels.
12679
12680              Relocations against object symbols can happen, eg when
12681              referencing a global array.  For an example of this see
12682              the _clz.o binary in libgcc.a.  */
12683           if (sym != symtab
12684               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12685               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12686             {
12687               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12688                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12689                     (long int)(rp - relocs),
12690                     printable_section_name (relsec));
12691               res = FALSE;
12692               continue;
12693             }
12694
12695           addend = 0;
12696           if (is_rela)
12697             addend += rp->r_addend;
12698           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12699              partial_inplace.  */
12700           if (!is_rela
12701               || (elf_header.e_machine == EM_XTENSA
12702                   && reloc_type == 1)
12703               || ((elf_header.e_machine == EM_PJ
12704                    || elf_header.e_machine == EM_PJ_OLD)
12705                   && reloc_type == 1)
12706               || ((elf_header.e_machine == EM_D30V
12707                    || elf_header.e_machine == EM_CYGNUS_D30V)
12708                   && reloc_type == 12))
12709             addend += byte_get (rloc, reloc_size);
12710
12711           if (is_32bit_pcrel_reloc (reloc_type)
12712               || is_64bit_pcrel_reloc (reloc_type))
12713             {
12714               /* On HPPA, all pc-relative relocations are biased by 8.  */
12715               if (elf_header.e_machine == EM_PARISC)
12716                 addend -= 8;
12717               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12718                         reloc_size);
12719             }
12720           else
12721             byte_put (rloc, addend + sym->st_value, reloc_size);
12722         }
12723
12724       free (symtab);
12725       /* Let the target specific reloc processing code know that
12726          we have finished with these relocs.  */
12727       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12728
12729       if (relocs_return)
12730         {
12731           * (Elf_Internal_Rela **) relocs_return = relocs;
12732           * num_relocs_return = num_relocs;
12733         }
12734       else
12735         free (relocs);
12736
12737       break;
12738     }
12739
12740   return res;
12741 }
12742
12743 #ifdef SUPPORT_DISASSEMBLY
12744 static bfd_boolean
12745 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12746 {
12747   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12748
12749   /* FIXME: XXX -- to be done --- XXX */
12750
12751   return TRUE;
12752 }
12753 #endif
12754
12755 /* Reads in the contents of SECTION from FILE, returning a pointer
12756    to a malloc'ed buffer or NULL if something went wrong.  */
12757
12758 static char *
12759 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12760 {
12761   bfd_size_type num_bytes;
12762
12763   num_bytes = section->sh_size;
12764
12765   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12766     {
12767       printf (_("Section '%s' has no data to dump.\n"),
12768               printable_section_name (section));
12769       return NULL;
12770     }
12771
12772   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12773                              _("section contents"));
12774 }
12775
12776 /* Uncompresses a section that was compressed using zlib, in place.  */
12777
12778 static bfd_boolean
12779 uncompress_section_contents (unsigned char **buffer,
12780                              dwarf_size_type uncompressed_size,
12781                              dwarf_size_type *size)
12782 {
12783   dwarf_size_type compressed_size = *size;
12784   unsigned char * compressed_buffer = *buffer;
12785   unsigned char * uncompressed_buffer;
12786   z_stream strm;
12787   int rc;
12788
12789   /* It is possible the section consists of several compressed
12790      buffers concatenated together, so we uncompress in a loop.  */
12791   /* PR 18313: The state field in the z_stream structure is supposed
12792      to be invisible to the user (ie us), but some compilers will
12793      still complain about it being used without initialisation.  So
12794      we first zero the entire z_stream structure and then set the fields
12795      that we need.  */
12796   memset (& strm, 0, sizeof strm);
12797   strm.avail_in = compressed_size;
12798   strm.next_in = (Bytef *) compressed_buffer;
12799   strm.avail_out = uncompressed_size;
12800   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12801
12802   rc = inflateInit (& strm);
12803   while (strm.avail_in > 0)
12804     {
12805       if (rc != Z_OK)
12806         goto fail;
12807       strm.next_out = ((Bytef *) uncompressed_buffer
12808                        + (uncompressed_size - strm.avail_out));
12809       rc = inflate (&strm, Z_FINISH);
12810       if (rc != Z_STREAM_END)
12811         goto fail;
12812       rc = inflateReset (& strm);
12813     }
12814   rc = inflateEnd (& strm);
12815   if (rc != Z_OK
12816       || strm.avail_out != 0)
12817     goto fail;
12818
12819   *buffer = uncompressed_buffer;
12820   *size = uncompressed_size;
12821   return TRUE;
12822
12823  fail:
12824   free (uncompressed_buffer);
12825   /* Indicate decompression failure.  */
12826   *buffer = NULL;
12827   return FALSE;
12828 }
12829
12830 static bfd_boolean
12831 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12832 {
12833   Elf_Internal_Shdr *  relsec;
12834   bfd_size_type        num_bytes;
12835   unsigned char *      data;
12836   unsigned char *      end;
12837   unsigned char *      real_start;
12838   unsigned char *      start;
12839   bfd_boolean          some_strings_shown;
12840
12841   real_start = start = (unsigned char *) get_section_contents (section, file);
12842   if (start == NULL)
12843     /* PR 21820: Do not fail if the section was empty.  */
12844     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12845
12846   num_bytes = section->sh_size;
12847
12848   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12849
12850   if (decompress_dumps)
12851     {
12852       dwarf_size_type new_size = num_bytes;
12853       dwarf_size_type uncompressed_size = 0;
12854
12855       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12856         {
12857           Elf_Internal_Chdr chdr;
12858           unsigned int compression_header_size
12859             = get_compression_header (& chdr, (unsigned char *) start,
12860                                       num_bytes);
12861
12862           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12863             {
12864               warn (_("section '%s' has unsupported compress type: %d\n"),
12865                     printable_section_name (section), chdr.ch_type);
12866               return FALSE;
12867             }
12868           else if (chdr.ch_addralign != section->sh_addralign)
12869             {
12870               warn (_("compressed section '%s' is corrupted\n"),
12871                     printable_section_name (section));
12872               return FALSE;
12873             }
12874           uncompressed_size = chdr.ch_size;
12875           start += compression_header_size;
12876           new_size -= compression_header_size;
12877         }
12878       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12879         {
12880           /* Read the zlib header.  In this case, it should be "ZLIB"
12881              followed by the uncompressed section size, 8 bytes in
12882              big-endian order.  */
12883           uncompressed_size = start[4]; uncompressed_size <<= 8;
12884           uncompressed_size += start[5]; uncompressed_size <<= 8;
12885           uncompressed_size += start[6]; uncompressed_size <<= 8;
12886           uncompressed_size += start[7]; uncompressed_size <<= 8;
12887           uncompressed_size += start[8]; uncompressed_size <<= 8;
12888           uncompressed_size += start[9]; uncompressed_size <<= 8;
12889           uncompressed_size += start[10]; uncompressed_size <<= 8;
12890           uncompressed_size += start[11];
12891           start += 12;
12892           new_size -= 12;
12893         }
12894
12895       if (uncompressed_size)
12896         {
12897           if (uncompress_section_contents (& start,
12898                                            uncompressed_size, & new_size))
12899             num_bytes = new_size;
12900           else
12901             {
12902               error (_("Unable to decompress section %s\n"),
12903                      printable_section_name (section));
12904               return FALSE;
12905             }
12906         }
12907       else
12908         start = real_start;
12909     }
12910
12911   /* If the section being dumped has relocations against it the user might
12912      be expecting these relocations to have been applied.  Check for this
12913      case and issue a warning message in order to avoid confusion.
12914      FIXME: Maybe we ought to have an option that dumps a section with
12915      relocs applied ?  */
12916   for (relsec = section_headers;
12917        relsec < section_headers + elf_header.e_shnum;
12918        ++relsec)
12919     {
12920       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12921           || relsec->sh_info >= elf_header.e_shnum
12922           || section_headers + relsec->sh_info != section
12923           || relsec->sh_size == 0
12924           || relsec->sh_link >= elf_header.e_shnum)
12925         continue;
12926
12927       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12928       break;
12929     }
12930
12931   data = start;
12932   end  = start + num_bytes;
12933   some_strings_shown = FALSE;
12934
12935   while (data < end)
12936     {
12937       while (!ISPRINT (* data))
12938         if (++ data >= end)
12939           break;
12940
12941       if (data < end)
12942         {
12943           size_t maxlen = end - data;
12944
12945 #ifndef __MSVCRT__
12946           /* PR 11128: Use two separate invocations in order to work
12947              around bugs in the Solaris 8 implementation of printf.  */
12948           printf ("  [%6tx]  ", data - start);
12949 #else
12950           printf ("  [%6Ix]  ", (size_t) (data - start));
12951 #endif
12952           if (maxlen > 0)
12953             {
12954               print_symbol ((int) maxlen, (const char *) data);
12955               putchar ('\n');
12956               data += strnlen ((const char *) data, maxlen);
12957             }
12958           else
12959             {
12960               printf (_("<corrupt>\n"));
12961               data = end;
12962             }
12963           some_strings_shown = TRUE;
12964         }
12965     }
12966
12967   if (! some_strings_shown)
12968     printf (_("  No strings found in this section."));
12969
12970   free (real_start);
12971
12972   putchar ('\n');
12973   return TRUE;
12974 }
12975
12976 static bfd_boolean
12977 dump_section_as_bytes (Elf_Internal_Shdr * section,
12978                        FILE * file,
12979                        bfd_boolean relocate)
12980 {
12981   Elf_Internal_Shdr * relsec;
12982   bfd_size_type       bytes;
12983   bfd_size_type       section_size;
12984   bfd_vma             addr;
12985   unsigned char *     data;
12986   unsigned char *     real_start;
12987   unsigned char *     start;
12988
12989   real_start = start = (unsigned char *) get_section_contents (section, file);
12990   if (start == NULL)
12991     /* PR 21820: Do not fail if the section was empty.  */
12992     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12993
12994   section_size = section->sh_size;
12995
12996   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12997
12998   if (decompress_dumps)
12999     {
13000       dwarf_size_type new_size = section_size;
13001       dwarf_size_type uncompressed_size = 0;
13002
13003       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13004         {
13005           Elf_Internal_Chdr chdr;
13006           unsigned int compression_header_size
13007             = get_compression_header (& chdr, start, section_size);
13008
13009           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13010             {
13011               warn (_("section '%s' has unsupported compress type: %d\n"),
13012                     printable_section_name (section), chdr.ch_type);
13013               return FALSE;
13014             }
13015           else if (chdr.ch_addralign != section->sh_addralign)
13016             {
13017               warn (_("compressed section '%s' is corrupted\n"),
13018                     printable_section_name (section));
13019               return FALSE;
13020             }
13021           uncompressed_size = chdr.ch_size;
13022           start += compression_header_size;
13023           new_size -= compression_header_size;
13024         }
13025       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13026         {
13027           /* Read the zlib header.  In this case, it should be "ZLIB"
13028              followed by the uncompressed section size, 8 bytes in
13029              big-endian order.  */
13030           uncompressed_size = start[4]; uncompressed_size <<= 8;
13031           uncompressed_size += start[5]; uncompressed_size <<= 8;
13032           uncompressed_size += start[6]; uncompressed_size <<= 8;
13033           uncompressed_size += start[7]; uncompressed_size <<= 8;
13034           uncompressed_size += start[8]; uncompressed_size <<= 8;
13035           uncompressed_size += start[9]; uncompressed_size <<= 8;
13036           uncompressed_size += start[10]; uncompressed_size <<= 8;
13037           uncompressed_size += start[11];
13038           start += 12;
13039           new_size -= 12;
13040         }
13041
13042       if (uncompressed_size)
13043         {
13044           if (uncompress_section_contents (& start, uncompressed_size,
13045                                            & new_size))
13046             {
13047               section_size = new_size;
13048             }
13049           else
13050             {
13051               error (_("Unable to decompress section %s\n"),
13052                      printable_section_name (section));
13053               /* FIXME: Print the section anyway ?  */
13054               return FALSE;
13055             }
13056         }
13057       else
13058         start = real_start;
13059     }
13060
13061   if (relocate)
13062     {
13063       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13064         return FALSE;
13065     }
13066   else
13067     {
13068       /* If the section being dumped has relocations against it the user might
13069          be expecting these relocations to have been applied.  Check for this
13070          case and issue a warning message in order to avoid confusion.
13071          FIXME: Maybe we ought to have an option that dumps a section with
13072          relocs applied ?  */
13073       for (relsec = section_headers;
13074            relsec < section_headers + elf_header.e_shnum;
13075            ++relsec)
13076         {
13077           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13078               || relsec->sh_info >= elf_header.e_shnum
13079               || section_headers + relsec->sh_info != section
13080               || relsec->sh_size == 0
13081               || relsec->sh_link >= elf_header.e_shnum)
13082             continue;
13083
13084           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13085           break;
13086         }
13087     }
13088
13089   addr = section->sh_addr;
13090   bytes = section_size;
13091   data = start;
13092
13093   while (bytes)
13094     {
13095       int j;
13096       int k;
13097       int lbytes;
13098
13099       lbytes = (bytes > 16 ? 16 : bytes);
13100
13101       printf ("  0x%8.8lx ", (unsigned long) addr);
13102
13103       for (j = 0; j < 16; j++)
13104         {
13105           if (j < lbytes)
13106             printf ("%2.2x", data[j]);
13107           else
13108             printf ("  ");
13109
13110           if ((j & 3) == 3)
13111             printf (" ");
13112         }
13113
13114       for (j = 0; j < lbytes; j++)
13115         {
13116           k = data[j];
13117           if (k >= ' ' && k < 0x7f)
13118             printf ("%c", k);
13119           else
13120             printf (".");
13121         }
13122
13123       putchar ('\n');
13124
13125       data  += lbytes;
13126       addr  += lbytes;
13127       bytes -= lbytes;
13128     }
13129
13130   free (real_start);
13131
13132   putchar ('\n');
13133   return TRUE;
13134 }
13135
13136 static bfd_boolean
13137 load_specific_debug_section (enum dwarf_section_display_enum debug,
13138                              const Elf_Internal_Shdr * sec, void * file)
13139 {
13140   struct dwarf_section * section = &debug_displays [debug].section;
13141   char buf [64];
13142
13143   /* If it is already loaded, do nothing.  */
13144   if (section->start != NULL)
13145     return TRUE;
13146
13147   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13148   section->address = sec->sh_addr;
13149   section->user_data = NULL;
13150   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13151                                                sec->sh_offset, 1,
13152                                                sec->sh_size, buf);
13153   if (section->start == NULL)
13154     section->size = 0;
13155   else
13156     {
13157       unsigned char *start = section->start;
13158       dwarf_size_type size = sec->sh_size;
13159       dwarf_size_type uncompressed_size = 0;
13160
13161       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13162         {
13163           Elf_Internal_Chdr chdr;
13164           unsigned int compression_header_size;
13165
13166           if (size < (is_32bit_elf
13167                       ? sizeof (Elf32_External_Chdr)
13168                       : sizeof (Elf64_External_Chdr)))
13169             {
13170               warn (_("compressed section %s is too small to contain a compression header"),
13171                     section->name);
13172               return FALSE;
13173             }
13174
13175           compression_header_size = get_compression_header (&chdr, start, size);
13176
13177           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13178             {
13179               warn (_("section '%s' has unsupported compress type: %d\n"),
13180                     section->name, chdr.ch_type);
13181               return FALSE;
13182             }
13183           else if (chdr.ch_addralign != sec->sh_addralign)
13184             {
13185               warn (_("compressed section '%s' is corrupted\n"),
13186                     section->name);
13187               return FALSE;
13188             }
13189           uncompressed_size = chdr.ch_size;
13190           start += compression_header_size;
13191           size -= compression_header_size;
13192         }
13193       else if (size > 12 && streq ((char *) start, "ZLIB"))
13194         {
13195           /* Read the zlib header.  In this case, it should be "ZLIB"
13196              followed by the uncompressed section size, 8 bytes in
13197              big-endian order.  */
13198           uncompressed_size = start[4]; uncompressed_size <<= 8;
13199           uncompressed_size += start[5]; uncompressed_size <<= 8;
13200           uncompressed_size += start[6]; uncompressed_size <<= 8;
13201           uncompressed_size += start[7]; uncompressed_size <<= 8;
13202           uncompressed_size += start[8]; uncompressed_size <<= 8;
13203           uncompressed_size += start[9]; uncompressed_size <<= 8;
13204           uncompressed_size += start[10]; uncompressed_size <<= 8;
13205           uncompressed_size += start[11];
13206           start += 12;
13207           size -= 12;
13208         }
13209
13210       if (uncompressed_size)
13211         {
13212           if (uncompress_section_contents (&start, uncompressed_size,
13213                                            &size))
13214             {
13215               /* Free the compressed buffer, update the section buffer
13216                  and the section size if uncompress is successful.  */
13217               free (section->start);
13218               section->start = start;
13219             }
13220           else
13221             {
13222               error (_("Unable to decompress section %s\n"),
13223                      printable_section_name (sec));
13224               return FALSE;
13225             }
13226         }
13227
13228       section->size = size;
13229     }
13230
13231   if (section->start == NULL)
13232     return FALSE;
13233
13234   if (debug_displays [debug].relocate)
13235     {
13236       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13237                                & section->reloc_info, & section->num_relocs))
13238         return FALSE;
13239     }
13240   else
13241     {
13242       section->reloc_info = NULL;
13243       section->num_relocs = 0;
13244     }
13245
13246   return TRUE;
13247 }
13248
13249 /* If this is not NULL, load_debug_section will only look for sections
13250    within the list of sections given here.  */
13251 static unsigned int * section_subset = NULL;
13252
13253 bfd_boolean
13254 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13255 {
13256   struct dwarf_section * section = &debug_displays [debug].section;
13257   Elf_Internal_Shdr * sec;
13258
13259   /* Locate the debug section.  */
13260   sec = find_section_in_set (section->uncompressed_name, section_subset);
13261   if (sec != NULL)
13262     section->name = section->uncompressed_name;
13263   else
13264     {
13265       sec = find_section_in_set (section->compressed_name, section_subset);
13266       if (sec != NULL)
13267         section->name = section->compressed_name;
13268     }
13269   if (sec == NULL)
13270     return FALSE;
13271
13272   /* If we're loading from a subset of sections, and we've loaded
13273      a section matching this name before, it's likely that it's a
13274      different one.  */
13275   if (section_subset != NULL)
13276     free_debug_section (debug);
13277
13278   return load_specific_debug_section (debug, sec, (FILE *) file);
13279 }
13280
13281 void
13282 free_debug_section (enum dwarf_section_display_enum debug)
13283 {
13284   struct dwarf_section * section = &debug_displays [debug].section;
13285
13286   if (section->start == NULL)
13287     return;
13288
13289   free ((char *) section->start);
13290   section->start = NULL;
13291   section->address = 0;
13292   section->size = 0;
13293 }
13294
13295 static bfd_boolean
13296 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13297 {
13298   char * name = SECTION_NAME (section);
13299   const char * print_name = printable_section_name (section);
13300   bfd_size_type length;
13301   bfd_boolean result = TRUE;
13302   int i;
13303
13304   length = section->sh_size;
13305   if (length == 0)
13306     {
13307       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13308       return TRUE;
13309     }
13310   if (section->sh_type == SHT_NOBITS)
13311     {
13312       /* There is no point in dumping the contents of a debugging section
13313          which has the NOBITS type - the bits in the file will be random.
13314          This can happen when a file containing a .eh_frame section is
13315          stripped with the --only-keep-debug command line option.  */
13316       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13317               print_name);
13318       return FALSE;
13319     }
13320
13321   if (const_strneq (name, ".gnu.linkonce.wi."))
13322     name = ".debug_info";
13323
13324   /* See if we know how to display the contents of this section.  */
13325   for (i = 0; i < max; i++)
13326     if (streq (debug_displays[i].section.uncompressed_name, name)
13327         || (i == line && const_strneq (name, ".debug_line."))
13328         || streq (debug_displays[i].section.compressed_name, name))
13329       {
13330         struct dwarf_section * sec = &debug_displays [i].section;
13331         int secondary = (section != find_section (name));
13332
13333         if (secondary)
13334           free_debug_section ((enum dwarf_section_display_enum) i);
13335
13336         if (i == line && const_strneq (name, ".debug_line."))
13337           sec->name = name;
13338         else if (streq (sec->uncompressed_name, name))
13339           sec->name = sec->uncompressed_name;
13340         else
13341           sec->name = sec->compressed_name;
13342         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13343                                          section, file))
13344           {
13345             /* If this debug section is part of a CU/TU set in a .dwp file,
13346                restrict load_debug_section to the sections in that set.  */
13347             section_subset = find_cu_tu_set (file, shndx);
13348
13349             result &= debug_displays[i].display (sec, file);
13350
13351             section_subset = NULL;
13352
13353             if (secondary || (i != info && i != abbrev))
13354               free_debug_section ((enum dwarf_section_display_enum) i);
13355           }
13356
13357         break;
13358       }
13359
13360   if (i == max)
13361     {
13362       printf (_("Unrecognized debug section: %s\n"), print_name);
13363       result = FALSE;
13364     }
13365
13366   return result;
13367 }
13368
13369 /* Set DUMP_SECTS for all sections where dumps were requested
13370    based on section name.  */
13371
13372 static void
13373 initialise_dumps_byname (void)
13374 {
13375   struct dump_list_entry * cur;
13376
13377   for (cur = dump_sects_byname; cur; cur = cur->next)
13378     {
13379       unsigned int i;
13380       bfd_boolean any = FALSE;
13381
13382       for (i = 0; i < elf_header.e_shnum; i++)
13383         if (streq (SECTION_NAME (section_headers + i), cur->name))
13384           {
13385             request_dump_bynumber (i, cur->type);
13386             any = TRUE;
13387           }
13388
13389       if (!any)
13390         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13391               cur->name);
13392     }
13393 }
13394
13395 static bfd_boolean
13396 process_section_contents (FILE * file)
13397 {
13398   Elf_Internal_Shdr * section;
13399   unsigned int i;
13400   bfd_boolean res = TRUE;
13401
13402   if (! do_dump)
13403     return TRUE;
13404
13405   initialise_dumps_byname ();
13406
13407   for (i = 0, section = section_headers;
13408        i < elf_header.e_shnum && i < num_dump_sects;
13409        i++, section++)
13410     {
13411 #ifdef SUPPORT_DISASSEMBLY
13412       if (dump_sects[i] & DISASS_DUMP)
13413         disassemble_section (section, file);
13414 #endif
13415       if (dump_sects[i] & HEX_DUMP)
13416         {
13417           if (! dump_section_as_bytes (section, file, FALSE))
13418             res = FALSE;
13419         }
13420
13421       if (dump_sects[i] & RELOC_DUMP)
13422         {
13423           if (! dump_section_as_bytes (section, file, TRUE))
13424             res = FALSE;
13425         }
13426
13427       if (dump_sects[i] & STRING_DUMP)
13428         {
13429           if (! dump_section_as_strings (section, file))
13430             res = FALSE;
13431         }
13432
13433       if (dump_sects[i] & DEBUG_DUMP)
13434         {
13435           if (! display_debug_section (i, section, file))
13436             res = FALSE;
13437         }
13438     }
13439
13440   /* Check to see if the user requested a
13441      dump of a section that does not exist.  */
13442   while (i < num_dump_sects)
13443     {
13444       if (dump_sects[i])
13445         {
13446           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13447           res = FALSE;
13448         }
13449       i++;
13450     }
13451
13452   return res;
13453 }
13454
13455 static void
13456 process_mips_fpe_exception (int mask)
13457 {
13458   if (mask)
13459     {
13460       bfd_boolean first = TRUE;
13461
13462       if (mask & OEX_FPU_INEX)
13463         fputs ("INEX", stdout), first = FALSE;
13464       if (mask & OEX_FPU_UFLO)
13465         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13466       if (mask & OEX_FPU_OFLO)
13467         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13468       if (mask & OEX_FPU_DIV0)
13469         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13470       if (mask & OEX_FPU_INVAL)
13471         printf ("%sINVAL", first ? "" : "|");
13472     }
13473   else
13474     fputs ("0", stdout);
13475 }
13476
13477 /* Display's the value of TAG at location P.  If TAG is
13478    greater than 0 it is assumed to be an unknown tag, and
13479    a message is printed to this effect.  Otherwise it is
13480    assumed that a message has already been printed.
13481
13482    If the bottom bit of TAG is set it assumed to have a
13483    string value, otherwise it is assumed to have an integer
13484    value.
13485
13486    Returns an updated P pointing to the first unread byte
13487    beyond the end of TAG's value.
13488
13489    Reads at or beyond END will not be made.  */
13490
13491 static unsigned char *
13492 display_tag_value (signed int tag,
13493                    unsigned char * p,
13494                    const unsigned char * const end)
13495 {
13496   unsigned long val;
13497
13498   if (tag > 0)
13499     printf ("  Tag_unknown_%d: ", tag);
13500
13501   if (p >= end)
13502     {
13503       warn (_("<corrupt tag>\n"));
13504     }
13505   else if (tag & 1)
13506     {
13507       /* PR 17531 file: 027-19978-0.004.  */
13508       size_t maxlen = (end - p) - 1;
13509
13510       putchar ('"');
13511       if (maxlen > 0)
13512         {
13513           print_symbol ((int) maxlen, (const char *) p);
13514           p += strnlen ((char *) p, maxlen) + 1;
13515         }
13516       else
13517         {
13518           printf (_("<corrupt string tag>"));
13519           p = (unsigned char *) end;
13520         }
13521       printf ("\"\n");
13522     }
13523   else
13524     {
13525       unsigned int len;
13526
13527       val = read_uleb128 (p, &len, end);
13528       p += len;
13529       printf ("%ld (0x%lx)\n", val, val);
13530     }
13531
13532   assert (p <= end);
13533   return p;
13534 }
13535
13536 /* ARC ABI attributes section.  */
13537
13538 static unsigned char *
13539 display_arc_attribute (unsigned char * p,
13540                        const unsigned char * const end)
13541 {
13542   unsigned int tag;
13543   unsigned int len;
13544   unsigned int val;
13545
13546   tag = read_uleb128 (p, &len, end);
13547   p += len;
13548
13549   switch (tag)
13550     {
13551     case Tag_ARC_PCS_config:
13552       val = read_uleb128 (p, &len, end);
13553       p += len;
13554       printf ("  Tag_ARC_PCS_config: ");
13555       switch (val)
13556         {
13557         case 0:
13558           printf (_("Absent/Non standard\n"));
13559           break;
13560         case 1:
13561           printf (_("Bare metal/mwdt\n"));
13562           break;
13563         case 2:
13564           printf (_("Bare metal/newlib\n"));
13565           break;
13566         case 3:
13567           printf (_("Linux/uclibc\n"));
13568           break;
13569         case 4:
13570           printf (_("Linux/glibc\n"));
13571           break;
13572         default:
13573           printf (_("Unknown\n"));
13574           break;
13575         }
13576       break;
13577
13578     case Tag_ARC_CPU_base:
13579       val = read_uleb128 (p, &len, end);
13580       p += len;
13581       printf ("  Tag_ARC_CPU_base: ");
13582       switch (val)
13583         {
13584         default:
13585         case TAG_CPU_NONE:
13586           printf (_("Absent\n"));
13587           break;
13588         case TAG_CPU_ARC6xx:
13589           printf ("ARC6xx\n");
13590           break;
13591         case TAG_CPU_ARC7xx:
13592           printf ("ARC7xx\n");
13593           break;
13594         case TAG_CPU_ARCEM:
13595           printf ("ARCEM\n");
13596           break;
13597         case TAG_CPU_ARCHS:
13598           printf ("ARCHS\n");
13599           break;
13600         }
13601       break;
13602
13603     case Tag_ARC_CPU_variation:
13604       val = read_uleb128 (p, &len, end);
13605       p += len;
13606       printf ("  Tag_ARC_CPU_variation: ");
13607       switch (val)
13608         {
13609         default:
13610           if (val > 0 && val < 16)
13611               printf ("Core%d\n", val);
13612           else
13613               printf ("Unknown\n");
13614           break;
13615
13616         case 0:
13617           printf (_("Absent\n"));
13618           break;
13619         }
13620       break;
13621
13622     case Tag_ARC_CPU_name:
13623       printf ("  Tag_ARC_CPU_name: ");
13624       p = display_tag_value (-1, p, end);
13625       break;
13626
13627     case Tag_ARC_ABI_rf16:
13628       val = read_uleb128 (p, &len, end);
13629       p += len;
13630       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13631       break;
13632
13633     case Tag_ARC_ABI_osver:
13634       val = read_uleb128 (p, &len, end);
13635       p += len;
13636       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13637       break;
13638
13639     case Tag_ARC_ABI_pic:
13640     case Tag_ARC_ABI_sda:
13641       val = read_uleb128 (p, &len, end);
13642       p += len;
13643       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13644               : "  Tag_ARC_ABI_pic: ");
13645       switch (val)
13646         {
13647         case 0:
13648           printf (_("Absent\n"));
13649           break;
13650         case 1:
13651           printf ("MWDT\n");
13652           break;
13653         case 2:
13654           printf ("GNU\n");
13655           break;
13656         default:
13657           printf (_("Unknown\n"));
13658           break;
13659         }
13660       break;
13661
13662     case Tag_ARC_ABI_tls:
13663       val = read_uleb128 (p, &len, end);
13664       p += len;
13665       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13666       break;
13667
13668     case Tag_ARC_ABI_enumsize:
13669       val = read_uleb128 (p, &len, end);
13670       p += len;
13671       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13672               _("smallest"));
13673       break;
13674
13675     case Tag_ARC_ABI_exceptions:
13676       val = read_uleb128 (p, &len, end);
13677       p += len;
13678       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13679               : _("default"));
13680       break;
13681
13682     case Tag_ARC_ABI_double_size:
13683       val = read_uleb128 (p, &len, end);
13684       p += len;
13685       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13686       break;
13687
13688     case Tag_ARC_ISA_config:
13689       printf ("  Tag_ARC_ISA_config: ");
13690       p = display_tag_value (-1, p, end);
13691       break;
13692
13693     case Tag_ARC_ISA_apex:
13694       printf ("  Tag_ARC_ISA_apex: ");
13695       p = display_tag_value (-1, p, end);
13696       break;
13697
13698     case Tag_ARC_ISA_mpy_option:
13699       val = read_uleb128 (p, &len, end);
13700       p += len;
13701       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13702       break;
13703
13704     default:
13705       return display_tag_value (tag & 1, p, end);
13706     }
13707
13708   return p;
13709 }
13710
13711 /* ARM EABI attributes section.  */
13712 typedef struct
13713 {
13714   unsigned int tag;
13715   const char * name;
13716   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13717   unsigned int type;
13718   const char ** table;
13719 } arm_attr_public_tag;
13720
13721 static const char * arm_attr_tag_CPU_arch[] =
13722   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13723    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13724    "v8-M.mainline"};
13725 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13726 static const char * arm_attr_tag_THUMB_ISA_use[] =
13727   {"No", "Thumb-1", "Thumb-2", "Yes"};
13728 static const char * arm_attr_tag_FP_arch[] =
13729   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13730    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13731 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13732 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13733   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13734    "NEON for ARMv8.1"};
13735 static const char * arm_attr_tag_PCS_config[] =
13736   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13737    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13738 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13739   {"V6", "SB", "TLS", "Unused"};
13740 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13741   {"Absolute", "PC-relative", "SB-relative", "None"};
13742 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13743   {"Absolute", "PC-relative", "None"};
13744 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13745   {"None", "direct", "GOT-indirect"};
13746 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13747   {"None", "??? 1", "2", "??? 3", "4"};
13748 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13749 static const char * arm_attr_tag_ABI_FP_denormal[] =
13750   {"Unused", "Needed", "Sign only"};
13751 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13752 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13753 static const char * arm_attr_tag_ABI_FP_number_model[] =
13754   {"Unused", "Finite", "RTABI", "IEEE 754"};
13755 static const char * arm_attr_tag_ABI_enum_size[] =
13756   {"Unused", "small", "int", "forced to int"};
13757 static const char * arm_attr_tag_ABI_HardFP_use[] =
13758   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13759 static const char * arm_attr_tag_ABI_VFP_args[] =
13760   {"AAPCS", "VFP registers", "custom", "compatible"};
13761 static const char * arm_attr_tag_ABI_WMMX_args[] =
13762   {"AAPCS", "WMMX registers", "custom"};
13763 static const char * arm_attr_tag_ABI_optimization_goals[] =
13764   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13765     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13766 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13767   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13768     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13769 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13770 static const char * arm_attr_tag_FP_HP_extension[] =
13771   {"Not Allowed", "Allowed"};
13772 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13773   {"None", "IEEE 754", "Alternative Format"};
13774 static const char * arm_attr_tag_DSP_extension[] =
13775   {"Follow architecture", "Allowed"};
13776 static const char * arm_attr_tag_MPextension_use[] =
13777   {"Not Allowed", "Allowed"};
13778 static const char * arm_attr_tag_DIV_use[] =
13779   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13780     "Allowed in v7-A with integer division extension"};
13781 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13782 static const char * arm_attr_tag_Virtualization_use[] =
13783   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13784     "TrustZone and Virtualization Extensions"};
13785 static const char * arm_attr_tag_MPextension_use_legacy[] =
13786   {"Not Allowed", "Allowed"};
13787
13788 #define LOOKUP(id, name) \
13789   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13790 static arm_attr_public_tag arm_attr_public_tags[] =
13791 {
13792   {4, "CPU_raw_name", 1, NULL},
13793   {5, "CPU_name", 1, NULL},
13794   LOOKUP(6, CPU_arch),
13795   {7, "CPU_arch_profile", 0, NULL},
13796   LOOKUP(8, ARM_ISA_use),
13797   LOOKUP(9, THUMB_ISA_use),
13798   LOOKUP(10, FP_arch),
13799   LOOKUP(11, WMMX_arch),
13800   LOOKUP(12, Advanced_SIMD_arch),
13801   LOOKUP(13, PCS_config),
13802   LOOKUP(14, ABI_PCS_R9_use),
13803   LOOKUP(15, ABI_PCS_RW_data),
13804   LOOKUP(16, ABI_PCS_RO_data),
13805   LOOKUP(17, ABI_PCS_GOT_use),
13806   LOOKUP(18, ABI_PCS_wchar_t),
13807   LOOKUP(19, ABI_FP_rounding),
13808   LOOKUP(20, ABI_FP_denormal),
13809   LOOKUP(21, ABI_FP_exceptions),
13810   LOOKUP(22, ABI_FP_user_exceptions),
13811   LOOKUP(23, ABI_FP_number_model),
13812   {24, "ABI_align_needed", 0, NULL},
13813   {25, "ABI_align_preserved", 0, NULL},
13814   LOOKUP(26, ABI_enum_size),
13815   LOOKUP(27, ABI_HardFP_use),
13816   LOOKUP(28, ABI_VFP_args),
13817   LOOKUP(29, ABI_WMMX_args),
13818   LOOKUP(30, ABI_optimization_goals),
13819   LOOKUP(31, ABI_FP_optimization_goals),
13820   {32, "compatibility", 0, NULL},
13821   LOOKUP(34, CPU_unaligned_access),
13822   LOOKUP(36, FP_HP_extension),
13823   LOOKUP(38, ABI_FP_16bit_format),
13824   LOOKUP(42, MPextension_use),
13825   LOOKUP(44, DIV_use),
13826   LOOKUP(46, DSP_extension),
13827   {64, "nodefaults", 0, NULL},
13828   {65, "also_compatible_with", 0, NULL},
13829   LOOKUP(66, T2EE_use),
13830   {67, "conformance", 1, NULL},
13831   LOOKUP(68, Virtualization_use),
13832   LOOKUP(70, MPextension_use_legacy)
13833 };
13834 #undef LOOKUP
13835
13836 static unsigned char *
13837 display_arm_attribute (unsigned char * p,
13838                        const unsigned char * const end)
13839 {
13840   unsigned int tag;
13841   unsigned int len;
13842   unsigned int val;
13843   arm_attr_public_tag * attr;
13844   unsigned i;
13845   unsigned int type;
13846
13847   tag = read_uleb128 (p, &len, end);
13848   p += len;
13849   attr = NULL;
13850   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13851     {
13852       if (arm_attr_public_tags[i].tag == tag)
13853         {
13854           attr = &arm_attr_public_tags[i];
13855           break;
13856         }
13857     }
13858
13859   if (attr)
13860     {
13861       printf ("  Tag_%s: ", attr->name);
13862       switch (attr->type)
13863         {
13864         case 0:
13865           switch (tag)
13866             {
13867             case 7: /* Tag_CPU_arch_profile.  */
13868               val = read_uleb128 (p, &len, end);
13869               p += len;
13870               switch (val)
13871                 {
13872                 case 0: printf (_("None\n")); break;
13873                 case 'A': printf (_("Application\n")); break;
13874                 case 'R': printf (_("Realtime\n")); break;
13875                 case 'M': printf (_("Microcontroller\n")); break;
13876                 case 'S': printf (_("Application or Realtime\n")); break;
13877                 default: printf ("??? (%d)\n", val); break;
13878                 }
13879               break;
13880
13881             case 24: /* Tag_align_needed.  */
13882               val = read_uleb128 (p, &len, end);
13883               p += len;
13884               switch (val)
13885                 {
13886                 case 0: printf (_("None\n")); break;
13887                 case 1: printf (_("8-byte\n")); break;
13888                 case 2: printf (_("4-byte\n")); break;
13889                 case 3: printf ("??? 3\n"); break;
13890                 default:
13891                   if (val <= 12)
13892                     printf (_("8-byte and up to %d-byte extended\n"),
13893                             1 << val);
13894                   else
13895                     printf ("??? (%d)\n", val);
13896                   break;
13897                 }
13898               break;
13899
13900             case 25: /* Tag_align_preserved.  */
13901               val = read_uleb128 (p, &len, end);
13902               p += len;
13903               switch (val)
13904                 {
13905                 case 0: printf (_("None\n")); break;
13906                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13907                 case 2: printf (_("8-byte\n")); break;
13908                 case 3: printf ("??? 3\n"); break;
13909                 default:
13910                   if (val <= 12)
13911                     printf (_("8-byte and up to %d-byte extended\n"),
13912                             1 << val);
13913                   else
13914                     printf ("??? (%d)\n", val);
13915                   break;
13916                 }
13917               break;
13918
13919             case 32: /* Tag_compatibility.  */
13920               {
13921                 val = read_uleb128 (p, &len, end);
13922                 p += len;
13923                 printf (_("flag = %d, vendor = "), val);
13924                 if (p < end - 1)
13925                   {
13926                     size_t maxlen = (end - p) - 1;
13927
13928                     print_symbol ((int) maxlen, (const char *) p);
13929                     p += strnlen ((char *) p, maxlen) + 1;
13930                   }
13931                 else
13932                   {
13933                     printf (_("<corrupt>"));
13934                     p = (unsigned char *) end;
13935                   }
13936                 putchar ('\n');
13937               }
13938               break;
13939
13940             case 64: /* Tag_nodefaults.  */
13941               /* PR 17531: file: 001-505008-0.01.  */
13942               if (p < end)
13943                 p++;
13944               printf (_("True\n"));
13945               break;
13946
13947             case 65: /* Tag_also_compatible_with.  */
13948               val = read_uleb128 (p, &len, end);
13949               p += len;
13950               if (val == 6 /* Tag_CPU_arch.  */)
13951                 {
13952                   val = read_uleb128 (p, &len, end);
13953                   p += len;
13954                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13955                     printf ("??? (%d)\n", val);
13956                   else
13957                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13958                 }
13959               else
13960                 printf ("???\n");
13961               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13962                 ;
13963               break;
13964
13965             default:
13966               printf (_("<unknown: %d>\n"), tag);
13967               break;
13968             }
13969           return p;
13970
13971         case 1:
13972           return display_tag_value (-1, p, end);
13973         case 2:
13974           return display_tag_value (0, p, end);
13975
13976         default:
13977           assert (attr->type & 0x80);
13978           val = read_uleb128 (p, &len, end);
13979           p += len;
13980           type = attr->type & 0x7f;
13981           if (val >= type)
13982             printf ("??? (%d)\n", val);
13983           else
13984             printf ("%s\n", attr->table[val]);
13985           return p;
13986         }
13987     }
13988
13989   return display_tag_value (tag, p, end);
13990 }
13991
13992 static unsigned char *
13993 display_gnu_attribute (unsigned char * p,
13994                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13995                        const unsigned char * const end)
13996 {
13997   int tag;
13998   unsigned int len;
13999   unsigned int val;
14000
14001   tag = read_uleb128 (p, &len, end);
14002   p += len;
14003
14004   /* Tag_compatibility is the only generic GNU attribute defined at
14005      present.  */
14006   if (tag == 32)
14007     {
14008       val = read_uleb128 (p, &len, end);
14009       p += len;
14010
14011       printf (_("flag = %d, vendor = "), val);
14012       if (p == end)
14013         {
14014           printf (_("<corrupt>\n"));
14015           warn (_("corrupt vendor attribute\n"));
14016         }
14017       else
14018         {
14019           if (p < end - 1)
14020             {
14021               size_t maxlen = (end - p) - 1;
14022
14023               print_symbol ((int) maxlen, (const char *) p);
14024               p += strnlen ((char *) p, maxlen) + 1;
14025             }
14026           else
14027             {
14028               printf (_("<corrupt>"));
14029               p = (unsigned char *) end;
14030             }
14031           putchar ('\n');
14032         }
14033       return p;
14034     }
14035
14036   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14037     return display_proc_gnu_attribute (p, tag, end);
14038
14039   return display_tag_value (tag, p, end);
14040 }
14041
14042 static unsigned char *
14043 display_power_gnu_attribute (unsigned char * p,
14044                              unsigned int tag,
14045                              const unsigned char * const end)
14046 {
14047   unsigned int len;
14048   unsigned int val;
14049
14050   if (tag == Tag_GNU_Power_ABI_FP)
14051     {
14052       val = read_uleb128 (p, &len, end);
14053       p += len;
14054       printf ("  Tag_GNU_Power_ABI_FP: ");
14055       if (len == 0)
14056         {
14057           printf (_("<corrupt>\n"));
14058           return p;
14059         }
14060
14061       if (val > 15)
14062         printf ("(%#x), ", val);
14063
14064       switch (val & 3)
14065         {
14066         case 0:
14067           printf (_("unspecified hard/soft float, "));
14068           break;
14069         case 1:
14070           printf (_("hard float, "));
14071           break;
14072         case 2:
14073           printf (_("soft float, "));
14074           break;
14075         case 3:
14076           printf (_("single-precision hard float, "));
14077           break;
14078         }
14079
14080       switch (val & 0xC)
14081         {
14082         case 0:
14083           printf (_("unspecified long double\n"));
14084           break;
14085         case 4:
14086           printf (_("128-bit IBM long double\n"));
14087           break;
14088         case 8:
14089           printf (_("64-bit long double\n"));
14090           break;
14091         case 12:
14092           printf (_("128-bit IEEE long double\n"));
14093           break;
14094         }
14095       return p;
14096     }
14097
14098   if (tag == Tag_GNU_Power_ABI_Vector)
14099     {
14100       val = read_uleb128 (p, &len, end);
14101       p += len;
14102       printf ("  Tag_GNU_Power_ABI_Vector: ");
14103       if (len == 0)
14104         {
14105           printf (_("<corrupt>\n"));
14106           return p;
14107         }
14108
14109       if (val > 3)
14110         printf ("(%#x), ", val);
14111
14112       switch (val & 3)
14113         {
14114         case 0:
14115           printf (_("unspecified\n"));
14116           break;
14117         case 1:
14118           printf (_("generic\n"));
14119           break;
14120         case 2:
14121           printf ("AltiVec\n");
14122           break;
14123         case 3:
14124           printf ("SPE\n");
14125           break;
14126         }
14127       return p;
14128     }
14129
14130   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14131     {
14132       val = read_uleb128 (p, &len, end);
14133       p += len;
14134       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14135       if (len == 0)
14136         {
14137           printf (_("<corrupt>\n"));
14138           return p;
14139         }
14140
14141       if (val > 2)
14142         printf ("(%#x), ", val);
14143
14144       switch (val & 3)
14145         {
14146         case 0:
14147           printf (_("unspecified\n"));
14148           break;
14149         case 1:
14150           printf ("r3/r4\n");
14151           break;
14152         case 2:
14153           printf (_("memory\n"));
14154           break;
14155         case 3:
14156           printf ("???\n");
14157           break;
14158         }
14159       return p;
14160     }
14161
14162   return display_tag_value (tag & 1, p, end);
14163 }
14164
14165 static unsigned char *
14166 display_s390_gnu_attribute (unsigned char * p,
14167                             unsigned int tag,
14168                             const unsigned char * const end)
14169 {
14170   unsigned int len;
14171   int val;
14172
14173   if (tag == Tag_GNU_S390_ABI_Vector)
14174     {
14175       val = read_uleb128 (p, &len, end);
14176       p += len;
14177       printf ("  Tag_GNU_S390_ABI_Vector: ");
14178
14179       switch (val)
14180         {
14181         case 0:
14182           printf (_("any\n"));
14183           break;
14184         case 1:
14185           printf (_("software\n"));
14186           break;
14187         case 2:
14188           printf (_("hardware\n"));
14189           break;
14190         default:
14191           printf ("??? (%d)\n", val);
14192           break;
14193         }
14194       return p;
14195    }
14196
14197   return display_tag_value (tag & 1, p, end);
14198 }
14199
14200 static void
14201 display_sparc_hwcaps (unsigned int mask)
14202 {
14203   if (mask)
14204     {
14205       bfd_boolean first = TRUE;
14206
14207       if (mask & ELF_SPARC_HWCAP_MUL32)
14208         fputs ("mul32", stdout), first = FALSE;
14209       if (mask & ELF_SPARC_HWCAP_DIV32)
14210         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14211       if (mask & ELF_SPARC_HWCAP_FSMULD)
14212         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14213       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14214         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14215       if (mask & ELF_SPARC_HWCAP_POPC)
14216         printf ("%spopc", first ? "" : "|"), first = FALSE;
14217       if (mask & ELF_SPARC_HWCAP_VIS)
14218         printf ("%svis", first ? "" : "|"), first = FALSE;
14219       if (mask & ELF_SPARC_HWCAP_VIS2)
14220         printf ("%svis2", first ? "" : "|"), first = FALSE;
14221       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14222         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14223       if (mask & ELF_SPARC_HWCAP_FMAF)
14224         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14225       if (mask & ELF_SPARC_HWCAP_VIS3)
14226         printf ("%svis3", first ? "" : "|"), first = FALSE;
14227       if (mask & ELF_SPARC_HWCAP_HPC)
14228         printf ("%shpc", first ? "" : "|"), first = FALSE;
14229       if (mask & ELF_SPARC_HWCAP_RANDOM)
14230         printf ("%srandom", first ? "" : "|"), first = FALSE;
14231       if (mask & ELF_SPARC_HWCAP_TRANS)
14232         printf ("%strans", first ? "" : "|"), first = FALSE;
14233       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14234         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14235       if (mask & ELF_SPARC_HWCAP_IMA)
14236         printf ("%sima", first ? "" : "|"), first = FALSE;
14237       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14238         printf ("%scspare", first ? "" : "|"), first = FALSE;
14239     }
14240   else
14241     fputc ('0', stdout);
14242   fputc ('\n', stdout);
14243 }
14244
14245 static void
14246 display_sparc_hwcaps2 (unsigned int mask)
14247 {
14248   if (mask)
14249     {
14250       bfd_boolean first = TRUE;
14251
14252       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14253         fputs ("fjathplus", stdout), first = FALSE;
14254       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14255         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14256       if (mask & ELF_SPARC_HWCAP2_ADP)
14257         printf ("%sadp", first ? "" : "|"), first = FALSE;
14258       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14259         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14260       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14261         printf ("%smwait", first ? "" : "|"), first = FALSE;
14262       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14263         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14264       if (mask & ELF_SPARC_HWCAP2_XMONT)
14265         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14266       if (mask & ELF_SPARC_HWCAP2_NSEC)
14267         printf ("%snsec", first ? "" : "|"), first = FALSE;
14268       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14269         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14270       if (mask & ELF_SPARC_HWCAP2_FJDES)
14271         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14272       if (mask & ELF_SPARC_HWCAP2_FJAES)
14273         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14274     }
14275   else
14276     fputc ('0', stdout);
14277   fputc ('\n', stdout);
14278 }
14279
14280 static unsigned char *
14281 display_sparc_gnu_attribute (unsigned char * p,
14282                              unsigned int tag,
14283                              const unsigned char * const end)
14284 {
14285   unsigned int len;
14286   int val;
14287
14288   if (tag == Tag_GNU_Sparc_HWCAPS)
14289     {
14290       val = read_uleb128 (p, &len, end);
14291       p += len;
14292       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14293       display_sparc_hwcaps (val);
14294       return p;
14295     }
14296   if (tag == Tag_GNU_Sparc_HWCAPS2)
14297     {
14298       val = read_uleb128 (p, &len, end);
14299       p += len;
14300       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14301       display_sparc_hwcaps2 (val);
14302       return p;
14303     }
14304
14305   return display_tag_value (tag, p, end);
14306 }
14307
14308 static void
14309 print_mips_fp_abi_value (unsigned int val)
14310 {
14311   switch (val)
14312     {
14313     case Val_GNU_MIPS_ABI_FP_ANY:
14314       printf (_("Hard or soft float\n"));
14315       break;
14316     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14317       printf (_("Hard float (double precision)\n"));
14318       break;
14319     case Val_GNU_MIPS_ABI_FP_SINGLE:
14320       printf (_("Hard float (single precision)\n"));
14321       break;
14322     case Val_GNU_MIPS_ABI_FP_SOFT:
14323       printf (_("Soft float\n"));
14324       break;
14325     case Val_GNU_MIPS_ABI_FP_OLD_64:
14326       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14327       break;
14328     case Val_GNU_MIPS_ABI_FP_XX:
14329       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14330       break;
14331     case Val_GNU_MIPS_ABI_FP_64:
14332       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14333       break;
14334     case Val_GNU_MIPS_ABI_FP_64A:
14335       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14336       break;
14337     case Val_GNU_MIPS_ABI_FP_NAN2008:
14338       printf (_("NaN 2008 compatibility\n"));
14339       break;
14340     default:
14341       printf ("??? (%d)\n", val);
14342       break;
14343     }
14344 }
14345
14346 static unsigned char *
14347 display_mips_gnu_attribute (unsigned char * p,
14348                             unsigned int tag,
14349                             const unsigned char * const end)
14350 {
14351   if (tag == Tag_GNU_MIPS_ABI_FP)
14352     {
14353       unsigned int len;
14354       unsigned int val;
14355
14356       val = read_uleb128 (p, &len, end);
14357       p += len;
14358       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14359
14360       print_mips_fp_abi_value (val);
14361
14362       return p;
14363    }
14364
14365   if (tag == Tag_GNU_MIPS_ABI_MSA)
14366     {
14367       unsigned int len;
14368       unsigned int val;
14369
14370       val = read_uleb128 (p, &len, end);
14371       p += len;
14372       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14373
14374       switch (val)
14375         {
14376         case Val_GNU_MIPS_ABI_MSA_ANY:
14377           printf (_("Any MSA or not\n"));
14378           break;
14379         case Val_GNU_MIPS_ABI_MSA_128:
14380           printf (_("128-bit MSA\n"));
14381           break;
14382         default:
14383           printf ("??? (%d)\n", val);
14384           break;
14385         }
14386       return p;
14387     }
14388
14389   return display_tag_value (tag & 1, p, end);
14390 }
14391
14392 static unsigned char *
14393 display_tic6x_attribute (unsigned char * p,
14394                          const unsigned char * const end)
14395 {
14396   unsigned int tag;
14397   unsigned int len;
14398   int val;
14399
14400   tag = read_uleb128 (p, &len, end);
14401   p += len;
14402
14403   switch (tag)
14404     {
14405     case Tag_ISA:
14406       val = read_uleb128 (p, &len, end);
14407       p += len;
14408       printf ("  Tag_ISA: ");
14409
14410       switch (val)
14411         {
14412         case C6XABI_Tag_ISA_none:
14413           printf (_("None\n"));
14414           break;
14415         case C6XABI_Tag_ISA_C62X:
14416           printf ("C62x\n");
14417           break;
14418         case C6XABI_Tag_ISA_C67X:
14419           printf ("C67x\n");
14420           break;
14421         case C6XABI_Tag_ISA_C67XP:
14422           printf ("C67x+\n");
14423           break;
14424         case C6XABI_Tag_ISA_C64X:
14425           printf ("C64x\n");
14426           break;
14427         case C6XABI_Tag_ISA_C64XP:
14428           printf ("C64x+\n");
14429           break;
14430         case C6XABI_Tag_ISA_C674X:
14431           printf ("C674x\n");
14432           break;
14433         default:
14434           printf ("??? (%d)\n", val);
14435           break;
14436         }
14437       return p;
14438
14439     case Tag_ABI_wchar_t:
14440       val = read_uleb128 (p, &len, end);
14441       p += len;
14442       printf ("  Tag_ABI_wchar_t: ");
14443       switch (val)
14444         {
14445         case 0:
14446           printf (_("Not used\n"));
14447           break;
14448         case 1:
14449           printf (_("2 bytes\n"));
14450           break;
14451         case 2:
14452           printf (_("4 bytes\n"));
14453           break;
14454         default:
14455           printf ("??? (%d)\n", val);
14456           break;
14457         }
14458       return p;
14459
14460     case Tag_ABI_stack_align_needed:
14461       val = read_uleb128 (p, &len, end);
14462       p += len;
14463       printf ("  Tag_ABI_stack_align_needed: ");
14464       switch (val)
14465         {
14466         case 0:
14467           printf (_("8-byte\n"));
14468           break;
14469         case 1:
14470           printf (_("16-byte\n"));
14471           break;
14472         default:
14473           printf ("??? (%d)\n", val);
14474           break;
14475         }
14476       return p;
14477
14478     case Tag_ABI_stack_align_preserved:
14479       val = read_uleb128 (p, &len, end);
14480       p += len;
14481       printf ("  Tag_ABI_stack_align_preserved: ");
14482       switch (val)
14483         {
14484         case 0:
14485           printf (_("8-byte\n"));
14486           break;
14487         case 1:
14488           printf (_("16-byte\n"));
14489           break;
14490         default:
14491           printf ("??? (%d)\n", val);
14492           break;
14493         }
14494       return p;
14495
14496     case Tag_ABI_DSBT:
14497       val = read_uleb128 (p, &len, end);
14498       p += len;
14499       printf ("  Tag_ABI_DSBT: ");
14500       switch (val)
14501         {
14502         case 0:
14503           printf (_("DSBT addressing not used\n"));
14504           break;
14505         case 1:
14506           printf (_("DSBT addressing used\n"));
14507           break;
14508         default:
14509           printf ("??? (%d)\n", val);
14510           break;
14511         }
14512       return p;
14513
14514     case Tag_ABI_PID:
14515       val = read_uleb128 (p, &len, end);
14516       p += len;
14517       printf ("  Tag_ABI_PID: ");
14518       switch (val)
14519         {
14520         case 0:
14521           printf (_("Data addressing position-dependent\n"));
14522           break;
14523         case 1:
14524           printf (_("Data addressing position-independent, GOT near DP\n"));
14525           break;
14526         case 2:
14527           printf (_("Data addressing position-independent, GOT far from DP\n"));
14528           break;
14529         default:
14530           printf ("??? (%d)\n", val);
14531           break;
14532         }
14533       return p;
14534
14535     case Tag_ABI_PIC:
14536       val = read_uleb128 (p, &len, end);
14537       p += len;
14538       printf ("  Tag_ABI_PIC: ");
14539       switch (val)
14540         {
14541         case 0:
14542           printf (_("Code addressing position-dependent\n"));
14543           break;
14544         case 1:
14545           printf (_("Code addressing position-independent\n"));
14546           break;
14547         default:
14548           printf ("??? (%d)\n", val);
14549           break;
14550         }
14551       return p;
14552
14553     case Tag_ABI_array_object_alignment:
14554       val = read_uleb128 (p, &len, end);
14555       p += len;
14556       printf ("  Tag_ABI_array_object_alignment: ");
14557       switch (val)
14558         {
14559         case 0:
14560           printf (_("8-byte\n"));
14561           break;
14562         case 1:
14563           printf (_("4-byte\n"));
14564           break;
14565         case 2:
14566           printf (_("16-byte\n"));
14567           break;
14568         default:
14569           printf ("??? (%d)\n", val);
14570           break;
14571         }
14572       return p;
14573
14574     case Tag_ABI_array_object_align_expected:
14575       val = read_uleb128 (p, &len, end);
14576       p += len;
14577       printf ("  Tag_ABI_array_object_align_expected: ");
14578       switch (val)
14579         {
14580         case 0:
14581           printf (_("8-byte\n"));
14582           break;
14583         case 1:
14584           printf (_("4-byte\n"));
14585           break;
14586         case 2:
14587           printf (_("16-byte\n"));
14588           break;
14589         default:
14590           printf ("??? (%d)\n", val);
14591           break;
14592         }
14593       return p;
14594
14595     case Tag_ABI_compatibility:
14596       {
14597         val = read_uleb128 (p, &len, end);
14598         p += len;
14599         printf ("  Tag_ABI_compatibility: ");
14600         printf (_("flag = %d, vendor = "), val);
14601         if (p < end - 1)
14602           {
14603             size_t maxlen = (end - p) - 1;
14604
14605             print_symbol ((int) maxlen, (const char *) p);
14606             p += strnlen ((char *) p, maxlen) + 1;
14607           }
14608         else
14609           {
14610             printf (_("<corrupt>"));
14611             p = (unsigned char *) end;
14612           }
14613         putchar ('\n');
14614         return p;
14615       }
14616
14617     case Tag_ABI_conformance:
14618       {
14619         printf ("  Tag_ABI_conformance: \"");
14620         if (p < end - 1)
14621           {
14622             size_t maxlen = (end - p) - 1;
14623
14624             print_symbol ((int) maxlen, (const char *) p);
14625             p += strnlen ((char *) p, maxlen) + 1;
14626           }
14627         else
14628           {
14629             printf (_("<corrupt>"));
14630             p = (unsigned char *) end;
14631           }
14632         printf ("\"\n");
14633         return p;
14634       }
14635     }
14636
14637   return display_tag_value (tag, p, end);
14638 }
14639
14640 static void
14641 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14642 {
14643   unsigned long addr = 0;
14644   size_t bytes = end - p;
14645
14646   assert (end > p);
14647   while (bytes)
14648     {
14649       int j;
14650       int k;
14651       int lbytes = (bytes > 16 ? 16 : bytes);
14652
14653       printf ("  0x%8.8lx ", addr);
14654
14655       for (j = 0; j < 16; j++)
14656         {
14657           if (j < lbytes)
14658             printf ("%2.2x", p[j]);
14659           else
14660             printf ("  ");
14661
14662           if ((j & 3) == 3)
14663             printf (" ");
14664         }
14665
14666       for (j = 0; j < lbytes; j++)
14667         {
14668           k = p[j];
14669           if (k >= ' ' && k < 0x7f)
14670             printf ("%c", k);
14671           else
14672             printf (".");
14673         }
14674
14675       putchar ('\n');
14676
14677       p  += lbytes;
14678       bytes -= lbytes;
14679       addr += lbytes;
14680     }
14681
14682   putchar ('\n');
14683 }
14684
14685 static unsigned char *
14686 display_msp430x_attribute (unsigned char * p,
14687                            const unsigned char * const end)
14688 {
14689   unsigned int len;
14690   unsigned int val;
14691   unsigned int tag;
14692
14693   tag = read_uleb128 (p, & len, end);
14694   p += len;
14695
14696   switch (tag)
14697     {
14698     case OFBA_MSPABI_Tag_ISA:
14699       val = read_uleb128 (p, &len, end);
14700       p += len;
14701       printf ("  Tag_ISA: ");
14702       switch (val)
14703         {
14704         case 0: printf (_("None\n")); break;
14705         case 1: printf (_("MSP430\n")); break;
14706         case 2: printf (_("MSP430X\n")); break;
14707         default: printf ("??? (%d)\n", val); break;
14708         }
14709       break;
14710
14711     case OFBA_MSPABI_Tag_Code_Model:
14712       val = read_uleb128 (p, &len, end);
14713       p += len;
14714       printf ("  Tag_Code_Model: ");
14715       switch (val)
14716         {
14717         case 0: printf (_("None\n")); break;
14718         case 1: printf (_("Small\n")); break;
14719         case 2: printf (_("Large\n")); break;
14720         default: printf ("??? (%d)\n", val); break;
14721         }
14722       break;
14723
14724     case OFBA_MSPABI_Tag_Data_Model:
14725       val = read_uleb128 (p, &len, end);
14726       p += len;
14727       printf ("  Tag_Data_Model: ");
14728       switch (val)
14729         {
14730         case 0: printf (_("None\n")); break;
14731         case 1: printf (_("Small\n")); break;
14732         case 2: printf (_("Large\n")); break;
14733         case 3: printf (_("Restricted Large\n")); break;
14734         default: printf ("??? (%d)\n", val); break;
14735         }
14736       break;
14737
14738     default:
14739       printf (_("  <unknown tag %d>: "), tag);
14740
14741       if (tag & 1)
14742         {
14743           putchar ('"');
14744           if (p < end - 1)
14745             {
14746               size_t maxlen = (end - p) - 1;
14747
14748               print_symbol ((int) maxlen, (const char *) p);
14749               p += strnlen ((char *) p, maxlen) + 1;
14750             }
14751           else
14752             {
14753               printf (_("<corrupt>"));
14754               p = (unsigned char *) end;
14755             }
14756           printf ("\"\n");
14757         }
14758       else
14759         {
14760           val = read_uleb128 (p, &len, end);
14761           p += len;
14762           printf ("%d (0x%x)\n", val, val);
14763         }
14764       break;
14765    }
14766
14767   assert (p <= end);
14768   return p;
14769 }
14770
14771 static bfd_boolean
14772 process_attributes (FILE * file,
14773                     const char * public_name,
14774                     unsigned int proc_type,
14775                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14776                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14777 {
14778   Elf_Internal_Shdr * sect;
14779   unsigned i;
14780   bfd_boolean res = TRUE;
14781
14782   /* Find the section header so that we get the size.  */
14783   for (i = 0, sect = section_headers;
14784        i < elf_header.e_shnum;
14785        i++, sect++)
14786     {
14787       unsigned char * contents;
14788       unsigned char * p;
14789
14790       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14791         continue;
14792
14793       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14794                                              sect->sh_size, _("attributes"));
14795       if (contents == NULL)
14796         {
14797           res = FALSE;
14798           continue;
14799         }
14800
14801       p = contents;
14802       /* The first character is the version of the attributes.
14803          Currently only version 1, (aka 'A') is recognised here.  */
14804       if (*p != 'A')
14805         {
14806           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14807           res = FALSE;
14808         }
14809       else
14810         {
14811           bfd_vma section_len;
14812
14813           section_len = sect->sh_size - 1;
14814           p++;
14815
14816           while (section_len > 0)
14817             {
14818               bfd_vma attr_len;
14819               unsigned int namelen;
14820               bfd_boolean public_section;
14821               bfd_boolean gnu_section;
14822
14823               if (section_len <= 4)
14824                 {
14825                   error (_("Tag section ends prematurely\n"));
14826                   res = FALSE;
14827                   break;
14828                 }
14829               attr_len = byte_get (p, 4);
14830               p += 4;
14831
14832               if (attr_len > section_len)
14833                 {
14834                   error (_("Bad attribute length (%u > %u)\n"),
14835                           (unsigned) attr_len, (unsigned) section_len);
14836                   attr_len = section_len;
14837                   res = FALSE;
14838                 }
14839               /* PR 17531: file: 001-101425-0.004  */
14840               else if (attr_len < 5)
14841                 {
14842                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14843                   res = FALSE;
14844                   break;
14845                 }
14846
14847               section_len -= attr_len;
14848               attr_len -= 4;
14849
14850               namelen = strnlen ((char *) p, attr_len) + 1;
14851               if (namelen == 0 || namelen >= attr_len)
14852                 {
14853                   error (_("Corrupt attribute section name\n"));
14854                   res = FALSE;
14855                   break;
14856                 }
14857
14858               printf (_("Attribute Section: "));
14859               print_symbol (INT_MAX, (const char *) p);
14860               putchar ('\n');
14861
14862               if (public_name && streq ((char *) p, public_name))
14863                 public_section = TRUE;
14864               else
14865                 public_section = FALSE;
14866
14867               if (streq ((char *) p, "gnu"))
14868                 gnu_section = TRUE;
14869               else
14870                 gnu_section = FALSE;
14871
14872               p += namelen;
14873               attr_len -= namelen;
14874
14875               while (attr_len > 0 && p < contents + sect->sh_size)
14876                 {
14877                   int tag;
14878                   int val;
14879                   bfd_vma size;
14880                   unsigned char * end;
14881
14882                   /* PR binutils/17531: Safe handling of corrupt files.  */
14883                   if (attr_len < 6)
14884                     {
14885                       error (_("Unused bytes at end of section\n"));
14886                       res = FALSE;
14887                       section_len = 0;
14888                       break;
14889                     }
14890
14891                   tag = *(p++);
14892                   size = byte_get (p, 4);
14893                   if (size > attr_len)
14894                     {
14895                       error (_("Bad subsection length (%u > %u)\n"),
14896                               (unsigned) size, (unsigned) attr_len);
14897                       res = FALSE;
14898                       size = attr_len;
14899                     }
14900                   /* PR binutils/17531: Safe handling of corrupt files.  */
14901                   if (size < 6)
14902                     {
14903                       error (_("Bad subsection length (%u < 6)\n"),
14904                               (unsigned) size);
14905                       res = FALSE;
14906                       section_len = 0;
14907                       break;
14908                     }
14909
14910                   attr_len -= size;
14911                   end = p + size - 1;
14912                   assert (end <= contents + sect->sh_size);
14913                   p += 4;
14914
14915                   switch (tag)
14916                     {
14917                     case 1:
14918                       printf (_("File Attributes\n"));
14919                       break;
14920                     case 2:
14921                       printf (_("Section Attributes:"));
14922                       goto do_numlist;
14923                     case 3:
14924                       printf (_("Symbol Attributes:"));
14925                       /* Fall through.  */
14926                     do_numlist:
14927                       for (;;)
14928                         {
14929                           unsigned int j;
14930
14931                           val = read_uleb128 (p, &j, end);
14932                           p += j;
14933                           if (val == 0)
14934                             break;
14935                           printf (" %d", val);
14936                         }
14937                       printf ("\n");
14938                       break;
14939                     default:
14940                       printf (_("Unknown tag: %d\n"), tag);
14941                       public_section = FALSE;
14942                       break;
14943                     }
14944
14945                   if (public_section && display_pub_attribute != NULL)
14946                     {
14947                       while (p < end)
14948                         p = display_pub_attribute (p, end);
14949                       assert (p == end);
14950                     }
14951                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14952                     {
14953                       while (p < end)
14954                         p = display_gnu_attribute (p,
14955                                                    display_proc_gnu_attribute,
14956                                                    end);
14957                       assert (p == end);
14958                     }
14959                   else if (p < end)
14960                     {
14961                       printf (_("  Unknown attribute:\n"));
14962                       display_raw_attribute (p, end);
14963                       p = end;
14964                     }
14965                   else
14966                     attr_len = 0;
14967                 }
14968             }
14969         }
14970
14971       free (contents);
14972     }
14973
14974   return res;
14975 }
14976
14977 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14978    Print the Address, Access and Initial fields of an entry at VMA ADDR
14979    and return the VMA of the next entry, or -1 if there was a problem.
14980    Does not read from DATA_END or beyond.  */
14981
14982 static bfd_vma
14983 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14984                       unsigned char * data_end)
14985 {
14986   printf ("  ");
14987   print_vma (addr, LONG_HEX);
14988   printf (" ");
14989   if (addr < pltgot + 0xfff0)
14990     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14991   else
14992     printf ("%10s", "");
14993   printf (" ");
14994   if (data == NULL)
14995     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14996   else
14997     {
14998       bfd_vma entry;
14999       unsigned char * from = data + addr - pltgot;
15000
15001       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15002         {
15003           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15004           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15005           return (bfd_vma) -1;
15006         }
15007       else
15008         {
15009           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15010           print_vma (entry, LONG_HEX);
15011         }
15012     }
15013   return addr + (is_32bit_elf ? 4 : 8);
15014 }
15015
15016 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15017    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15018    ADDR and return the VMA of the next entry.  */
15019
15020 static bfd_vma
15021 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15022 {
15023   printf ("  ");
15024   print_vma (addr, LONG_HEX);
15025   printf (" ");
15026   if (data == NULL)
15027     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15028   else
15029     {
15030       bfd_vma entry;
15031
15032       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15033       print_vma (entry, LONG_HEX);
15034     }
15035   return addr + (is_32bit_elf ? 4 : 8);
15036 }
15037
15038 static void
15039 print_mips_ases (unsigned int mask)
15040 {
15041   if (mask & AFL_ASE_DSP)
15042     fputs ("\n\tDSP ASE", stdout);
15043   if (mask & AFL_ASE_DSPR2)
15044     fputs ("\n\tDSP R2 ASE", stdout);
15045   if (mask & AFL_ASE_DSPR3)
15046     fputs ("\n\tDSP R3 ASE", stdout);
15047   if (mask & AFL_ASE_EVA)
15048     fputs ("\n\tEnhanced VA Scheme", stdout);
15049   if (mask & AFL_ASE_MCU)
15050     fputs ("\n\tMCU (MicroController) ASE", stdout);
15051   if (mask & AFL_ASE_MDMX)
15052     fputs ("\n\tMDMX ASE", stdout);
15053   if (mask & AFL_ASE_MIPS3D)
15054     fputs ("\n\tMIPS-3D ASE", stdout);
15055   if (mask & AFL_ASE_MT)
15056     fputs ("\n\tMT ASE", stdout);
15057   if (mask & AFL_ASE_SMARTMIPS)
15058     fputs ("\n\tSmartMIPS ASE", stdout);
15059   if (mask & AFL_ASE_VIRT)
15060     fputs ("\n\tVZ ASE", stdout);
15061   if (mask & AFL_ASE_MSA)
15062     fputs ("\n\tMSA ASE", stdout);
15063   if (mask & AFL_ASE_MIPS16)
15064     fputs ("\n\tMIPS16 ASE", stdout);
15065   if (mask & AFL_ASE_MICROMIPS)
15066     fputs ("\n\tMICROMIPS ASE", stdout);
15067   if (mask & AFL_ASE_XPA)
15068     fputs ("\n\tXPA ASE", stdout);
15069   if (mask & AFL_ASE_MIPS16E2)
15070     fputs ("\n\tMIPS16e2 ASE", stdout);
15071   if (mask == 0)
15072     fprintf (stdout, "\n\t%s", _("None"));
15073   else if ((mask & ~AFL_ASE_MASK) != 0)
15074     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15075 }
15076
15077 static void
15078 print_mips_isa_ext (unsigned int isa_ext)
15079 {
15080   switch (isa_ext)
15081     {
15082     case 0:
15083       fputs (_("None"), stdout);
15084       break;
15085     case AFL_EXT_XLR:
15086       fputs ("RMI XLR", stdout);
15087       break;
15088     case AFL_EXT_OCTEON3:
15089       fputs ("Cavium Networks Octeon3", stdout);
15090       break;
15091     case AFL_EXT_OCTEON2:
15092       fputs ("Cavium Networks Octeon2", stdout);
15093       break;
15094     case AFL_EXT_OCTEONP:
15095       fputs ("Cavium Networks OcteonP", stdout);
15096       break;
15097     case AFL_EXT_LOONGSON_3A:
15098       fputs ("Loongson 3A", stdout);
15099       break;
15100     case AFL_EXT_OCTEON:
15101       fputs ("Cavium Networks Octeon", stdout);
15102       break;
15103     case AFL_EXT_5900:
15104       fputs ("Toshiba R5900", stdout);
15105       break;
15106     case AFL_EXT_4650:
15107       fputs ("MIPS R4650", stdout);
15108       break;
15109     case AFL_EXT_4010:
15110       fputs ("LSI R4010", stdout);
15111       break;
15112     case AFL_EXT_4100:
15113       fputs ("NEC VR4100", stdout);
15114       break;
15115     case AFL_EXT_3900:
15116       fputs ("Toshiba R3900", stdout);
15117       break;
15118     case AFL_EXT_10000:
15119       fputs ("MIPS R10000", stdout);
15120       break;
15121     case AFL_EXT_SB1:
15122       fputs ("Broadcom SB-1", stdout);
15123       break;
15124     case AFL_EXT_4111:
15125       fputs ("NEC VR4111/VR4181", stdout);
15126       break;
15127     case AFL_EXT_4120:
15128       fputs ("NEC VR4120", stdout);
15129       break;
15130     case AFL_EXT_5400:
15131       fputs ("NEC VR5400", stdout);
15132       break;
15133     case AFL_EXT_5500:
15134       fputs ("NEC VR5500", stdout);
15135       break;
15136     case AFL_EXT_LOONGSON_2E:
15137       fputs ("ST Microelectronics Loongson 2E", stdout);
15138       break;
15139     case AFL_EXT_LOONGSON_2F:
15140       fputs ("ST Microelectronics Loongson 2F", stdout);
15141       break;
15142     case AFL_EXT_INTERAPTIV_MR2:
15143       fputs ("Imagination interAptiv MR2", stdout);
15144       break;
15145     default:
15146       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15147     }
15148 }
15149
15150 static signed int
15151 get_mips_reg_size (int reg_size)
15152 {
15153   return (reg_size == AFL_REG_NONE) ? 0
15154          : (reg_size == AFL_REG_32) ? 32
15155          : (reg_size == AFL_REG_64) ? 64
15156          : (reg_size == AFL_REG_128) ? 128
15157          : -1;
15158 }
15159
15160 static bfd_boolean
15161 process_mips_specific (FILE * file)
15162 {
15163   Elf_Internal_Dyn * entry;
15164   Elf_Internal_Shdr *sect = NULL;
15165   size_t liblist_offset = 0;
15166   size_t liblistno = 0;
15167   size_t conflictsno = 0;
15168   size_t options_offset = 0;
15169   size_t conflicts_offset = 0;
15170   size_t pltrelsz = 0;
15171   size_t pltrel = 0;
15172   bfd_vma pltgot = 0;
15173   bfd_vma mips_pltgot = 0;
15174   bfd_vma jmprel = 0;
15175   bfd_vma local_gotno = 0;
15176   bfd_vma gotsym = 0;
15177   bfd_vma symtabno = 0;
15178   bfd_boolean res = TRUE;
15179
15180   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15181                             display_mips_gnu_attribute))
15182     res = FALSE;
15183
15184   sect = find_section (".MIPS.abiflags");
15185
15186   if (sect != NULL)
15187     {
15188       Elf_External_ABIFlags_v0 *abiflags_ext;
15189       Elf_Internal_ABIFlags_v0 abiflags_in;
15190
15191       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15192         {
15193           error (_("Corrupt MIPS ABI Flags section.\n"));
15194           res = FALSE;
15195         }
15196       else
15197         {
15198           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15199                                    sect->sh_size, _("MIPS ABI Flags section"));
15200           if (abiflags_ext)
15201             {
15202               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15203               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15204               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15205               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15206               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15207               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15208               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15209               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15210               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15211               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15212               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15213
15214               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15215               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15216               if (abiflags_in.isa_rev > 1)
15217                 printf ("r%d", abiflags_in.isa_rev);
15218               printf ("\nGPR size: %d",
15219                       get_mips_reg_size (abiflags_in.gpr_size));
15220               printf ("\nCPR1 size: %d",
15221                       get_mips_reg_size (abiflags_in.cpr1_size));
15222               printf ("\nCPR2 size: %d",
15223                       get_mips_reg_size (abiflags_in.cpr2_size));
15224               fputs ("\nFP ABI: ", stdout);
15225               print_mips_fp_abi_value (abiflags_in.fp_abi);
15226               fputs ("ISA Extension: ", stdout);
15227               print_mips_isa_ext (abiflags_in.isa_ext);
15228               fputs ("\nASEs:", stdout);
15229               print_mips_ases (abiflags_in.ases);
15230               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15231               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15232               fputc ('\n', stdout);
15233               free (abiflags_ext);
15234             }
15235         }
15236     }
15237
15238   /* We have a lot of special sections.  Thanks SGI!  */
15239   if (dynamic_section == NULL)
15240     {
15241       /* No dynamic information available.  See if there is static GOT.  */
15242       sect = find_section (".got");
15243       if (sect != NULL)
15244         {
15245           unsigned char *data_end;
15246           unsigned char *data;
15247           bfd_vma ent, end;
15248           int addr_size;
15249
15250           pltgot = sect->sh_addr;
15251
15252           ent = pltgot;
15253           addr_size = (is_32bit_elf ? 4 : 8);
15254           end = pltgot + sect->sh_size;
15255
15256           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15257                                              end - pltgot, 1,
15258                                              _("Global Offset Table data"));
15259           /* PR 12855: Null data is handled gracefully throughout.  */
15260           data_end = data + (end - pltgot);
15261
15262           printf (_("\nStatic GOT:\n"));
15263           printf (_(" Canonical gp value: "));
15264           print_vma (ent + 0x7ff0, LONG_HEX);
15265           printf ("\n\n");
15266
15267           /* In a dynamic binary GOT[0] is reserved for the dynamic
15268              loader to store the lazy resolver pointer, however in
15269              a static binary it may well have been omitted and GOT
15270              reduced to a table of addresses.
15271              PR 21344: Check for the entry being fully available
15272              before fetching it.  */
15273           if (data
15274               && data + ent - pltgot + addr_size <= data_end
15275               && byte_get (data + ent - pltgot, addr_size) == 0)
15276             {
15277               printf (_(" Reserved entries:\n"));
15278               printf (_("  %*s %10s %*s\n"),
15279                       addr_size * 2, _("Address"), _("Access"),
15280                       addr_size * 2, _("Value"));
15281               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15282               printf ("\n");
15283               if (ent == (bfd_vma) -1)
15284                 goto sgot_print_fail;
15285
15286               /* Check for the MSB of GOT[1] being set, identifying a
15287                  GNU object.  This entry will be used by some runtime
15288                  loaders, to store the module pointer.  Otherwise this
15289                  is an ordinary local entry.
15290                  PR 21344: Check for the entry being fully available
15291                  before fetching it.  */
15292               if (data
15293                   && data + ent - pltgot + addr_size <= data_end
15294                   && (byte_get (data + ent - pltgot, addr_size)
15295                       >> (addr_size * 8 - 1)) != 0)
15296                 {
15297                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15298                   printf ("\n");
15299                   if (ent == (bfd_vma) -1)
15300                     goto sgot_print_fail;
15301                 }
15302               printf ("\n");
15303             }
15304
15305           if (ent < end)
15306             {
15307               printf (_(" Local entries:\n"));
15308               printf ("  %*s %10s %*s\n",
15309                       addr_size * 2, _("Address"), _("Access"),
15310                       addr_size * 2, _("Value"));
15311               while (ent < end)
15312                 {
15313                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15314                   printf ("\n");
15315                   if (ent == (bfd_vma) -1)
15316                     goto sgot_print_fail;
15317                 }
15318               printf ("\n");
15319             }
15320
15321         sgot_print_fail:
15322           if (data)
15323             free (data);
15324         }
15325       return res;
15326     }
15327
15328   for (entry = dynamic_section;
15329        /* PR 17531 file: 012-50589-0.004.  */
15330        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15331        ++entry)
15332     switch (entry->d_tag)
15333       {
15334       case DT_MIPS_LIBLIST:
15335         liblist_offset
15336           = offset_from_vma (file, entry->d_un.d_val,
15337                              liblistno * sizeof (Elf32_External_Lib));
15338         break;
15339       case DT_MIPS_LIBLISTNO:
15340         liblistno = entry->d_un.d_val;
15341         break;
15342       case DT_MIPS_OPTIONS:
15343         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15344         break;
15345       case DT_MIPS_CONFLICT:
15346         conflicts_offset
15347           = offset_from_vma (file, entry->d_un.d_val,
15348                              conflictsno * sizeof (Elf32_External_Conflict));
15349         break;
15350       case DT_MIPS_CONFLICTNO:
15351         conflictsno = entry->d_un.d_val;
15352         break;
15353       case DT_PLTGOT:
15354         pltgot = entry->d_un.d_ptr;
15355         break;
15356       case DT_MIPS_LOCAL_GOTNO:
15357         local_gotno = entry->d_un.d_val;
15358         break;
15359       case DT_MIPS_GOTSYM:
15360         gotsym = entry->d_un.d_val;
15361         break;
15362       case DT_MIPS_SYMTABNO:
15363         symtabno = entry->d_un.d_val;
15364         break;
15365       case DT_MIPS_PLTGOT:
15366         mips_pltgot = entry->d_un.d_ptr;
15367         break;
15368       case DT_PLTREL:
15369         pltrel = entry->d_un.d_val;
15370         break;
15371       case DT_PLTRELSZ:
15372         pltrelsz = entry->d_un.d_val;
15373         break;
15374       case DT_JMPREL:
15375         jmprel = entry->d_un.d_ptr;
15376         break;
15377       default:
15378         break;
15379       }
15380
15381   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15382     {
15383       Elf32_External_Lib * elib;
15384       size_t cnt;
15385
15386       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15387                                               liblistno,
15388                                               sizeof (Elf32_External_Lib),
15389                                               _("liblist section data"));
15390       if (elib)
15391         {
15392           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15393                   (unsigned long) liblistno);
15394           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15395                  stdout);
15396
15397           for (cnt = 0; cnt < liblistno; ++cnt)
15398             {
15399               Elf32_Lib liblist;
15400               time_t atime;
15401               char timebuf[128];
15402               struct tm * tmp;
15403
15404               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15405               atime = BYTE_GET (elib[cnt].l_time_stamp);
15406               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15407               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15408               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15409
15410               tmp = gmtime (&atime);
15411               snprintf (timebuf, sizeof (timebuf),
15412                         "%04u-%02u-%02uT%02u:%02u:%02u",
15413                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15414                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15415
15416               printf ("%3lu: ", (unsigned long) cnt);
15417               if (VALID_DYNAMIC_NAME (liblist.l_name))
15418                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15419               else
15420                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15421               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15422                       liblist.l_version);
15423
15424               if (liblist.l_flags == 0)
15425                 puts (_(" NONE"));
15426               else
15427                 {
15428                   static const struct
15429                   {
15430                     const char * name;
15431                     int bit;
15432                   }
15433                   l_flags_vals[] =
15434                   {
15435                     { " EXACT_MATCH", LL_EXACT_MATCH },
15436                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15437                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15438                     { " EXPORTS", LL_EXPORTS },
15439                     { " DELAY_LOAD", LL_DELAY_LOAD },
15440                     { " DELTA", LL_DELTA }
15441                   };
15442                   int flags = liblist.l_flags;
15443                   size_t fcnt;
15444
15445                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15446                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15447                       {
15448                         fputs (l_flags_vals[fcnt].name, stdout);
15449                         flags ^= l_flags_vals[fcnt].bit;
15450                       }
15451                   if (flags != 0)
15452                     printf (" %#x", (unsigned int) flags);
15453
15454                   puts ("");
15455                 }
15456             }
15457
15458           free (elib);
15459         }
15460       else
15461         res = FALSE;
15462     }
15463
15464   if (options_offset != 0)
15465     {
15466       Elf_External_Options * eopt;
15467       Elf_Internal_Options * iopt;
15468       Elf_Internal_Options * option;
15469       size_t offset;
15470       int cnt;
15471       sect = section_headers;
15472
15473       /* Find the section header so that we get the size.  */
15474       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15475       /* PR 17533 file: 012-277276-0.004.  */
15476       if (sect == NULL)
15477         {
15478           error (_("No MIPS_OPTIONS header found\n"));
15479           return FALSE;
15480         }
15481
15482       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15483                                                 sect->sh_size, _("options"));
15484       if (eopt)
15485         {
15486           iopt = (Elf_Internal_Options *)
15487               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15488           if (iopt == NULL)
15489             {
15490               error (_("Out of memory allocating space for MIPS options\n"));
15491               return FALSE;
15492             }
15493
15494           offset = cnt = 0;
15495           option = iopt;
15496
15497           while (offset <= sect->sh_size - sizeof (* eopt))
15498             {
15499               Elf_External_Options * eoption;
15500
15501               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15502
15503               option->kind = BYTE_GET (eoption->kind);
15504               option->size = BYTE_GET (eoption->size);
15505               option->section = BYTE_GET (eoption->section);
15506               option->info = BYTE_GET (eoption->info);
15507
15508               /* PR 17531: file: ffa0fa3b.  */
15509               if (option->size < sizeof (* eopt)
15510                   || offset + option->size > sect->sh_size)
15511                 {
15512                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15513                   return FALSE;
15514                 }
15515               offset += option->size;
15516
15517               ++option;
15518               ++cnt;
15519             }
15520
15521           printf (_("\nSection '%s' contains %d entries:\n"),
15522                   printable_section_name (sect), cnt);
15523
15524           option = iopt;
15525           offset = 0;
15526
15527           while (cnt-- > 0)
15528             {
15529               size_t len;
15530
15531               switch (option->kind)
15532                 {
15533                 case ODK_NULL:
15534                   /* This shouldn't happen.  */
15535                   printf (" NULL       %d %lx", option->section, option->info);
15536                   break;
15537                 case ODK_REGINFO:
15538                   printf (" REGINFO    ");
15539                   if (elf_header.e_machine == EM_MIPS)
15540                     {
15541                       /* 32bit form.  */
15542                       Elf32_External_RegInfo * ereg;
15543                       Elf32_RegInfo reginfo;
15544
15545                       ereg = (Elf32_External_RegInfo *) (option + 1);
15546                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15547                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15548                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15549                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15550                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15551                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15552
15553                       printf ("GPR %08lx  GP 0x%lx\n",
15554                               reginfo.ri_gprmask,
15555                               (unsigned long) reginfo.ri_gp_value);
15556                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15557                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15558                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15559                     }
15560                   else
15561                     {
15562                       /* 64 bit form.  */
15563                       Elf64_External_RegInfo * ereg;
15564                       Elf64_Internal_RegInfo reginfo;
15565
15566                       ereg = (Elf64_External_RegInfo *) (option + 1);
15567                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15568                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15569                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15570                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15571                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15572                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15573
15574                       printf ("GPR %08lx  GP 0x",
15575                               reginfo.ri_gprmask);
15576                       printf_vma (reginfo.ri_gp_value);
15577                       printf ("\n");
15578
15579                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15580                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15581                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15582                     }
15583                   ++option;
15584                   continue;
15585                 case ODK_EXCEPTIONS:
15586                   fputs (" EXCEPTIONS fpe_min(", stdout);
15587                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15588                   fputs (") fpe_max(", stdout);
15589                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15590                   fputs (")", stdout);
15591
15592                   if (option->info & OEX_PAGE0)
15593                     fputs (" PAGE0", stdout);
15594                   if (option->info & OEX_SMM)
15595                     fputs (" SMM", stdout);
15596                   if (option->info & OEX_FPDBUG)
15597                     fputs (" FPDBUG", stdout);
15598                   if (option->info & OEX_DISMISS)
15599                     fputs (" DISMISS", stdout);
15600                   break;
15601                 case ODK_PAD:
15602                   fputs (" PAD       ", stdout);
15603                   if (option->info & OPAD_PREFIX)
15604                     fputs (" PREFIX", stdout);
15605                   if (option->info & OPAD_POSTFIX)
15606                     fputs (" POSTFIX", stdout);
15607                   if (option->info & OPAD_SYMBOL)
15608                     fputs (" SYMBOL", stdout);
15609                   break;
15610                 case ODK_HWPATCH:
15611                   fputs (" HWPATCH   ", stdout);
15612                   if (option->info & OHW_R4KEOP)
15613                     fputs (" R4KEOP", stdout);
15614                   if (option->info & OHW_R8KPFETCH)
15615                     fputs (" R8KPFETCH", stdout);
15616                   if (option->info & OHW_R5KEOP)
15617                     fputs (" R5KEOP", stdout);
15618                   if (option->info & OHW_R5KCVTL)
15619                     fputs (" R5KCVTL", stdout);
15620                   break;
15621                 case ODK_FILL:
15622                   fputs (" FILL       ", stdout);
15623                   /* XXX Print content of info word?  */
15624                   break;
15625                 case ODK_TAGS:
15626                   fputs (" TAGS       ", stdout);
15627                   /* XXX Print content of info word?  */
15628                   break;
15629                 case ODK_HWAND:
15630                   fputs (" HWAND     ", stdout);
15631                   if (option->info & OHWA0_R4KEOP_CHECKED)
15632                     fputs (" R4KEOP_CHECKED", stdout);
15633                   if (option->info & OHWA0_R4KEOP_CLEAN)
15634                     fputs (" R4KEOP_CLEAN", stdout);
15635                   break;
15636                 case ODK_HWOR:
15637                   fputs (" HWOR      ", stdout);
15638                   if (option->info & OHWA0_R4KEOP_CHECKED)
15639                     fputs (" R4KEOP_CHECKED", stdout);
15640                   if (option->info & OHWA0_R4KEOP_CLEAN)
15641                     fputs (" R4KEOP_CLEAN", stdout);
15642                   break;
15643                 case ODK_GP_GROUP:
15644                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15645                           option->info & OGP_GROUP,
15646                           (option->info & OGP_SELF) >> 16);
15647                   break;
15648                 case ODK_IDENT:
15649                   printf (" IDENT     %#06lx  self-contained %#06lx",
15650                           option->info & OGP_GROUP,
15651                           (option->info & OGP_SELF) >> 16);
15652                   break;
15653                 default:
15654                   /* This shouldn't happen.  */
15655                   printf (" %3d ???     %d %lx",
15656                           option->kind, option->section, option->info);
15657                   break;
15658                 }
15659
15660               len = sizeof (* eopt);
15661               while (len < option->size)
15662                 {
15663                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15664
15665                   if (ISPRINT (datum))
15666                     printf ("%c", datum);
15667                   else
15668                     printf ("\\%03o", datum);
15669                   len ++;
15670                 }
15671               fputs ("\n", stdout);
15672
15673               offset += option->size;
15674               ++option;
15675             }
15676
15677           free (eopt);
15678         }
15679       else
15680         res = FALSE;
15681     }
15682
15683   if (conflicts_offset != 0 && conflictsno != 0)
15684     {
15685       Elf32_Conflict * iconf;
15686       size_t cnt;
15687
15688       if (dynamic_symbols == NULL)
15689         {
15690           error (_("conflict list found without a dynamic symbol table\n"));
15691           return FALSE;
15692         }
15693
15694       /* PR 21345 - print a slightly more helpful error message
15695          if we are sure that the cmalloc will fail.  */
15696       if (conflictsno * sizeof (* iconf) > current_file_size)
15697         {
15698           error (_("Overlarge number of conflicts detected: %lx\n"),
15699                  (long) conflictsno);
15700           return FALSE;
15701         }
15702
15703       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15704       if (iconf == NULL)
15705         {
15706           error (_("Out of memory allocating space for dynamic conflicts\n"));
15707           return FALSE;
15708         }
15709
15710       if (is_32bit_elf)
15711         {
15712           Elf32_External_Conflict * econf32;
15713
15714           econf32 = (Elf32_External_Conflict *)
15715               get_data (NULL, file, conflicts_offset, conflictsno,
15716                         sizeof (* econf32), _("conflict"));
15717           if (!econf32)
15718             return FALSE;
15719
15720           for (cnt = 0; cnt < conflictsno; ++cnt)
15721             iconf[cnt] = BYTE_GET (econf32[cnt]);
15722
15723           free (econf32);
15724         }
15725       else
15726         {
15727           Elf64_External_Conflict * econf64;
15728
15729           econf64 = (Elf64_External_Conflict *)
15730               get_data (NULL, file, conflicts_offset, conflictsno,
15731                         sizeof (* econf64), _("conflict"));
15732           if (!econf64)
15733             return FALSE;
15734
15735           for (cnt = 0; cnt < conflictsno; ++cnt)
15736             iconf[cnt] = BYTE_GET (econf64[cnt]);
15737
15738           free (econf64);
15739         }
15740
15741       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15742               (unsigned long) conflictsno);
15743       puts (_("  Num:    Index       Value  Name"));
15744
15745       for (cnt = 0; cnt < conflictsno; ++cnt)
15746         {
15747           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15748
15749           if (iconf[cnt] >= num_dynamic_syms)
15750             printf (_("<corrupt symbol index>"));
15751           else
15752             {
15753               Elf_Internal_Sym * psym;
15754
15755               psym = & dynamic_symbols[iconf[cnt]];
15756               print_vma (psym->st_value, FULL_HEX);
15757               putchar (' ');
15758               if (VALID_DYNAMIC_NAME (psym->st_name))
15759                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15760               else
15761                 printf (_("<corrupt: %14ld>"), psym->st_name);
15762             }
15763           putchar ('\n');
15764         }
15765
15766       free (iconf);
15767     }
15768
15769   if (pltgot != 0 && local_gotno != 0)
15770     {
15771       bfd_vma ent, local_end, global_end;
15772       size_t i, offset;
15773       unsigned char * data;
15774       unsigned char * data_end;
15775       int addr_size;
15776
15777       ent = pltgot;
15778       addr_size = (is_32bit_elf ? 4 : 8);
15779       local_end = pltgot + local_gotno * addr_size;
15780
15781       /* PR binutils/17533 file: 012-111227-0.004  */
15782       if (symtabno < gotsym)
15783         {
15784           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15785                  (unsigned long) gotsym, (unsigned long) symtabno);
15786           return FALSE;
15787         }
15788
15789       global_end = local_end + (symtabno - gotsym) * addr_size;
15790       /* PR 17531: file: 54c91a34.  */
15791       if (global_end < local_end)
15792         {
15793           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15794           return FALSE;
15795         }
15796
15797       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15798       data = (unsigned char *) get_data (NULL, file, offset,
15799                                          global_end - pltgot, 1,
15800                                          _("Global Offset Table data"));
15801       /* PR 12855: Null data is handled gracefully throughout.  */
15802       data_end = data + (global_end - pltgot);
15803
15804       printf (_("\nPrimary GOT:\n"));
15805       printf (_(" Canonical gp value: "));
15806       print_vma (pltgot + 0x7ff0, LONG_HEX);
15807       printf ("\n\n");
15808
15809       printf (_(" Reserved entries:\n"));
15810       printf (_("  %*s %10s %*s Purpose\n"),
15811               addr_size * 2, _("Address"), _("Access"),
15812               addr_size * 2, _("Initial"));
15813       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15814       printf (_(" Lazy resolver\n"));
15815       if (ent == (bfd_vma) -1)
15816         goto got_print_fail;
15817
15818       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15819          This entry will be used by some runtime loaders, to store the
15820          module pointer.  Otherwise this is an ordinary local entry.
15821          PR 21344: Check for the entry being fully available before
15822          fetching it.  */
15823       if (data
15824           && data + ent - pltgot + addr_size <= data_end
15825           && (byte_get (data + ent - pltgot, addr_size)
15826               >> (addr_size * 8 - 1)) != 0)
15827         {
15828           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15829           printf (_(" Module pointer (GNU extension)\n"));
15830           if (ent == (bfd_vma) -1)
15831             goto got_print_fail;
15832         }
15833       printf ("\n");
15834
15835       if (ent < local_end)
15836         {
15837           printf (_(" Local entries:\n"));
15838           printf ("  %*s %10s %*s\n",
15839                   addr_size * 2, _("Address"), _("Access"),
15840                   addr_size * 2, _("Initial"));
15841           while (ent < local_end)
15842             {
15843               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15844               printf ("\n");
15845               if (ent == (bfd_vma) -1)
15846                 goto got_print_fail;
15847             }
15848           printf ("\n");
15849         }
15850
15851       if (gotsym < symtabno)
15852         {
15853           int sym_width;
15854
15855           printf (_(" Global entries:\n"));
15856           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15857                   addr_size * 2, _("Address"),
15858                   _("Access"),
15859                   addr_size * 2, _("Initial"),
15860                   addr_size * 2, _("Sym.Val."),
15861                   _("Type"),
15862                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15863                   _("Ndx"), _("Name"));
15864
15865           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15866
15867           for (i = gotsym; i < symtabno; i++)
15868             {
15869               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15870               printf (" ");
15871
15872               if (dynamic_symbols == NULL)
15873                 printf (_("<no dynamic symbols>"));
15874               else if (i < num_dynamic_syms)
15875                 {
15876                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15877
15878                   print_vma (psym->st_value, LONG_HEX);
15879                   printf (" %-7s %3s ",
15880                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15881                           get_symbol_index_type (psym->st_shndx));
15882
15883                   if (VALID_DYNAMIC_NAME (psym->st_name))
15884                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15885                   else
15886                     printf (_("<corrupt: %14ld>"), psym->st_name);
15887                 }
15888               else
15889                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15890                         (unsigned long) i);
15891
15892               printf ("\n");
15893               if (ent == (bfd_vma) -1)
15894                 break;
15895             }
15896           printf ("\n");
15897         }
15898
15899     got_print_fail:
15900       if (data)
15901         free (data);
15902     }
15903
15904   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15905     {
15906       bfd_vma ent, end;
15907       size_t offset, rel_offset;
15908       unsigned long count, i;
15909       unsigned char * data;
15910       int addr_size, sym_width;
15911       Elf_Internal_Rela * rels;
15912
15913       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15914       if (pltrel == DT_RELA)
15915         {
15916           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15917             return FALSE;
15918         }
15919       else
15920         {
15921           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15922             return FALSE;
15923         }
15924
15925       ent = mips_pltgot;
15926       addr_size = (is_32bit_elf ? 4 : 8);
15927       end = mips_pltgot + (2 + count) * addr_size;
15928
15929       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15930       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15931                                          1, _("Procedure Linkage Table data"));
15932       if (data == NULL)
15933         return FALSE;
15934
15935       printf ("\nPLT GOT:\n\n");
15936       printf (_(" Reserved entries:\n"));
15937       printf (_("  %*s %*s Purpose\n"),
15938               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15939       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15940       printf (_(" PLT lazy resolver\n"));
15941       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15942       printf (_(" Module pointer\n"));
15943       printf ("\n");
15944
15945       printf (_(" Entries:\n"));
15946       printf ("  %*s %*s %*s %-7s %3s %s\n",
15947               addr_size * 2, _("Address"),
15948               addr_size * 2, _("Initial"),
15949               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15950       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15951       for (i = 0; i < count; i++)
15952         {
15953           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15954
15955           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15956           printf (" ");
15957
15958           if (idx >= num_dynamic_syms)
15959             printf (_("<corrupt symbol index: %lu>"), idx);
15960           else
15961             {
15962               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15963
15964               print_vma (psym->st_value, LONG_HEX);
15965               printf (" %-7s %3s ",
15966                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15967                       get_symbol_index_type (psym->st_shndx));
15968               if (VALID_DYNAMIC_NAME (psym->st_name))
15969                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15970               else
15971                 printf (_("<corrupt: %14ld>"), psym->st_name);
15972             }
15973           printf ("\n");
15974         }
15975       printf ("\n");
15976
15977       if (data)
15978         free (data);
15979       free (rels);
15980     }
15981
15982   return res;
15983 }
15984
15985 static bfd_boolean
15986 process_nds32_specific (FILE * file)
15987 {
15988   Elf_Internal_Shdr *sect = NULL;
15989
15990   sect = find_section (".nds32_e_flags");
15991   if (sect != NULL)
15992     {
15993       unsigned int *flag;
15994
15995       printf ("\nNDS32 elf flags section:\n");
15996       flag = get_data (NULL, file, sect->sh_offset, 1,
15997                        sect->sh_size, _("NDS32 elf flags section"));
15998
15999       if (! flag)
16000         return FALSE;
16001
16002       switch ((*flag) & 0x3)
16003         {
16004         case 0:
16005           printf ("(VEC_SIZE):\tNo entry.\n");
16006           break;
16007         case 1:
16008           printf ("(VEC_SIZE):\t4 bytes\n");
16009           break;
16010         case 2:
16011           printf ("(VEC_SIZE):\t16 bytes\n");
16012           break;
16013         case 3:
16014           printf ("(VEC_SIZE):\treserved\n");
16015           break;
16016         }
16017     }
16018
16019   return TRUE;
16020 }
16021
16022 static bfd_boolean
16023 process_gnu_liblist (FILE * file)
16024 {
16025   Elf_Internal_Shdr * section;
16026   Elf_Internal_Shdr * string_sec;
16027   Elf32_External_Lib * elib;
16028   char * strtab;
16029   size_t strtab_size;
16030   size_t cnt;
16031   unsigned i;
16032   bfd_boolean res = TRUE;
16033
16034   if (! do_arch)
16035     return TRUE;
16036
16037   for (i = 0, section = section_headers;
16038        i < elf_header.e_shnum;
16039        i++, section++)
16040     {
16041       switch (section->sh_type)
16042         {
16043         case SHT_GNU_LIBLIST:
16044           if (section->sh_link >= elf_header.e_shnum)
16045             break;
16046
16047           elib = (Elf32_External_Lib *)
16048               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16049                         _("liblist section data"));
16050
16051           if (elib == NULL)
16052             {
16053               res = FALSE;
16054               break;
16055             }
16056
16057           string_sec = section_headers + section->sh_link;
16058           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16059                                       string_sec->sh_size,
16060                                       _("liblist string table"));
16061           if (strtab == NULL
16062               || section->sh_entsize != sizeof (Elf32_External_Lib))
16063             {
16064               free (elib);
16065               free (strtab);
16066               res = FALSE;
16067               break;
16068             }
16069           strtab_size = string_sec->sh_size;
16070
16071           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16072                   printable_section_name (section),
16073                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16074
16075           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16076
16077           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16078                ++cnt)
16079             {
16080               Elf32_Lib liblist;
16081               time_t atime;
16082               char timebuf[128];
16083               struct tm * tmp;
16084
16085               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16086               atime = BYTE_GET (elib[cnt].l_time_stamp);
16087               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16088               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16089               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16090
16091               tmp = gmtime (&atime);
16092               snprintf (timebuf, sizeof (timebuf),
16093                         "%04u-%02u-%02uT%02u:%02u:%02u",
16094                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16095                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16096
16097               printf ("%3lu: ", (unsigned long) cnt);
16098               if (do_wide)
16099                 printf ("%-20s", liblist.l_name < strtab_size
16100                         ? strtab + liblist.l_name : _("<corrupt>"));
16101               else
16102                 printf ("%-20.20s", liblist.l_name < strtab_size
16103                         ? strtab + liblist.l_name : _("<corrupt>"));
16104               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16105                       liblist.l_version, liblist.l_flags);
16106             }
16107
16108           free (elib);
16109           free (strtab);
16110         }
16111     }
16112
16113   return res;
16114 }
16115
16116 static const char *
16117 get_note_type (unsigned e_type)
16118 {
16119   static char buff[64];
16120
16121   if (elf_header.e_type == ET_CORE)
16122     switch (e_type)
16123       {
16124       case NT_AUXV:
16125         return _("NT_AUXV (auxiliary vector)");
16126       case NT_PRSTATUS:
16127         return _("NT_PRSTATUS (prstatus structure)");
16128       case NT_FPREGSET:
16129         return _("NT_FPREGSET (floating point registers)");
16130       case NT_PRPSINFO:
16131         return _("NT_PRPSINFO (prpsinfo structure)");
16132       case NT_TASKSTRUCT:
16133         return _("NT_TASKSTRUCT (task structure)");
16134       case NT_PRXFPREG:
16135         return _("NT_PRXFPREG (user_xfpregs structure)");
16136       case NT_PPC_VMX:
16137         return _("NT_PPC_VMX (ppc Altivec registers)");
16138       case NT_PPC_VSX:
16139         return _("NT_PPC_VSX (ppc VSX registers)");
16140       case NT_PPC_TAR:
16141         return _("NT_PPC_TAR (ppc TAR register)");
16142       case NT_PPC_PPR:
16143         return _("NT_PPC_PPR (ppc PPR register)");
16144       case NT_PPC_DSCR:
16145         return _("NT_PPC_DSCR (ppc DSCR register)");
16146       case NT_PPC_EBB:
16147         return _("NT_PPC_EBB (ppc EBB registers)");
16148       case NT_PPC_PMU:
16149         return _("NT_PPC_PMU (ppc PMU registers)");
16150       case NT_PPC_TM_CGPR:
16151         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16152       case NT_PPC_TM_CFPR:
16153         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16154       case NT_PPC_TM_CVMX:
16155         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16156       case NT_PPC_TM_CVSX:
16157         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16158       case NT_PPC_TM_SPR:
16159         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16160       case NT_PPC_TM_CTAR:
16161         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16162       case NT_PPC_TM_CPPR:
16163         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16164       case NT_PPC_TM_CDSCR:
16165         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16166       case NT_386_TLS:
16167         return _("NT_386_TLS (x86 TLS information)");
16168       case NT_386_IOPERM:
16169         return _("NT_386_IOPERM (x86 I/O permissions)");
16170       case NT_X86_XSTATE:
16171         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16172       case NT_S390_HIGH_GPRS:
16173         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16174       case NT_S390_TIMER:
16175         return _("NT_S390_TIMER (s390 timer register)");
16176       case NT_S390_TODCMP:
16177         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16178       case NT_S390_TODPREG:
16179         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16180       case NT_S390_CTRS:
16181         return _("NT_S390_CTRS (s390 control registers)");
16182       case NT_S390_PREFIX:
16183         return _("NT_S390_PREFIX (s390 prefix register)");
16184       case NT_S390_LAST_BREAK:
16185         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16186       case NT_S390_SYSTEM_CALL:
16187         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16188       case NT_S390_TDB:
16189         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16190       case NT_S390_VXRS_LOW:
16191         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16192       case NT_S390_VXRS_HIGH:
16193         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16194       case NT_S390_GS_CB:
16195         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16196       case NT_S390_GS_BC:
16197         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16198       case NT_ARM_VFP:
16199         return _("NT_ARM_VFP (arm VFP registers)");
16200       case NT_ARM_TLS:
16201         return _("NT_ARM_TLS (AArch TLS registers)");
16202       case NT_ARM_HW_BREAK:
16203         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16204       case NT_ARM_HW_WATCH:
16205         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16206       case NT_PSTATUS:
16207         return _("NT_PSTATUS (pstatus structure)");
16208       case NT_FPREGS:
16209         return _("NT_FPREGS (floating point registers)");
16210       case NT_PSINFO:
16211         return _("NT_PSINFO (psinfo structure)");
16212       case NT_LWPSTATUS:
16213         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16214       case NT_LWPSINFO:
16215         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16216       case NT_WIN32PSTATUS:
16217         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16218       case NT_SIGINFO:
16219         return _("NT_SIGINFO (siginfo_t data)");
16220       case NT_FILE:
16221         return _("NT_FILE (mapped files)");
16222       default:
16223         break;
16224       }
16225   else
16226     switch (e_type)
16227       {
16228       case NT_VERSION:
16229         return _("NT_VERSION (version)");
16230       case NT_ARCH:
16231         return _("NT_ARCH (architecture)");
16232       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16233         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16234       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16235         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16236       default:
16237         break;
16238       }
16239
16240   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16241   return buff;
16242 }
16243
16244 static bfd_boolean
16245 print_core_note (Elf_Internal_Note *pnote)
16246 {
16247   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16248   bfd_vma count, page_size;
16249   unsigned char *descdata, *filenames, *descend;
16250
16251   if (pnote->type != NT_FILE)
16252     {
16253       if (do_wide)
16254         printf ("\n");
16255       return TRUE;
16256     }
16257
16258 #ifndef BFD64
16259   if (!is_32bit_elf)
16260     {
16261       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16262       /* Still "successful".  */
16263       return TRUE;
16264     }
16265 #endif
16266
16267   if (pnote->descsz < 2 * addr_size)
16268     {
16269       error (_("    Malformed note - too short for header\n"));
16270       return FALSE;
16271     }
16272
16273   descdata = (unsigned char *) pnote->descdata;
16274   descend = descdata + pnote->descsz;
16275
16276   if (descdata[pnote->descsz - 1] != '\0')
16277     {
16278       error (_("    Malformed note - does not end with \\0\n"));
16279       return FALSE;
16280     }
16281
16282   count = byte_get (descdata, addr_size);
16283   descdata += addr_size;
16284
16285   page_size = byte_get (descdata, addr_size);
16286   descdata += addr_size;
16287
16288   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16289     {
16290       error (_("    Malformed note - too short for supplied file count\n"));
16291       return FALSE;
16292     }
16293
16294   printf (_("    Page size: "));
16295   print_vma (page_size, DEC);
16296   printf ("\n");
16297
16298   printf (_("    %*s%*s%*s\n"),
16299           (int) (2 + 2 * addr_size), _("Start"),
16300           (int) (4 + 2 * addr_size), _("End"),
16301           (int) (4 + 2 * addr_size), _("Page Offset"));
16302   filenames = descdata + count * 3 * addr_size;
16303   while (count-- > 0)
16304     {
16305       bfd_vma start, end, file_ofs;
16306
16307       if (filenames == descend)
16308         {
16309           error (_("    Malformed note - filenames end too early\n"));
16310           return FALSE;
16311         }
16312
16313       start = byte_get (descdata, addr_size);
16314       descdata += addr_size;
16315       end = byte_get (descdata, addr_size);
16316       descdata += addr_size;
16317       file_ofs = byte_get (descdata, addr_size);
16318       descdata += addr_size;
16319
16320       printf ("    ");
16321       print_vma (start, FULL_HEX);
16322       printf ("  ");
16323       print_vma (end, FULL_HEX);
16324       printf ("  ");
16325       print_vma (file_ofs, FULL_HEX);
16326       printf ("\n        %s\n", filenames);
16327
16328       filenames += 1 + strlen ((char *) filenames);
16329     }
16330
16331   return TRUE;
16332 }
16333
16334 static const char *
16335 get_gnu_elf_note_type (unsigned e_type)
16336 {
16337   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16338   switch (e_type)
16339     {
16340     case NT_GNU_ABI_TAG:
16341       return _("NT_GNU_ABI_TAG (ABI version tag)");
16342     case NT_GNU_HWCAP:
16343       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16344     case NT_GNU_BUILD_ID:
16345       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16346     case NT_GNU_GOLD_VERSION:
16347       return _("NT_GNU_GOLD_VERSION (gold version)");
16348     case NT_GNU_PROPERTY_TYPE_0:
16349       return _("NT_GNU_PROPERTY_TYPE_0");
16350     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16351       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16352     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16353       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16354     default:
16355       {
16356         static char buff[64];
16357
16358         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16359         return buff;
16360       }
16361     }
16362 }
16363
16364 static void
16365 decode_x86_isa (unsigned int bitmask)
16366 {
16367   while (bitmask)
16368     {
16369       unsigned int bit = bitmask & (- bitmask);
16370
16371       bitmask &= ~ bit;
16372       switch (bit)
16373         {
16374         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16375         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16376         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16377         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16378         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16379         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16380         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16381         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16382         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16383         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16384         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16385         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16386         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16387         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16388         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16389         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16390         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16391         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16392         default: printf (_("<unknown: %x>"), bit); break;
16393         }
16394       if (bitmask)
16395         printf (", ");
16396     }
16397 }
16398
16399 static void
16400 decode_x86_feature (unsigned int type, unsigned int bitmask)
16401 {
16402   while (bitmask)
16403     {
16404       unsigned int bit = bitmask & (- bitmask);
16405
16406       bitmask &= ~ bit;
16407       switch (bit)
16408         {
16409         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16410           switch (type)
16411             {
16412             case GNU_PROPERTY_X86_FEATURE_1_AND:
16413               printf ("IBT");
16414               break;
16415             default:
16416               /* This should never happen.  */
16417               abort ();
16418             }
16419           break;
16420         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16421           switch (type)
16422             {
16423             case GNU_PROPERTY_X86_FEATURE_1_AND:
16424               printf ("SHSTK");
16425               break;
16426             default:
16427               /* This should never happen.  */
16428               abort ();
16429             }
16430           break;
16431         default:
16432           printf (_("<unknown: %x>"), bit);
16433           break;
16434         }
16435       if (bitmask)
16436         printf (", ");
16437     }
16438 }
16439
16440 static void
16441 print_gnu_property_note (Elf_Internal_Note * pnote)
16442 {
16443   unsigned char * ptr = (unsigned char *) pnote->descdata;
16444   unsigned char * ptr_end = ptr + pnote->descsz;
16445   unsigned int    size = is_32bit_elf ? 4 : 8;
16446
16447   printf (_("      Properties: "));
16448
16449   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16450     {
16451       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16452       return;
16453     }
16454
16455   while (1)
16456     {
16457       unsigned int j;
16458       unsigned int type = byte_get (ptr, 4);
16459       unsigned int datasz = byte_get (ptr + 4, 4);
16460
16461       ptr += 8;
16462
16463       if ((ptr + datasz) > ptr_end)
16464         {
16465           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16466                   type, datasz);
16467           break;
16468         }
16469
16470       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16471         {
16472           if (elf_header.e_machine == EM_X86_64
16473               || elf_header.e_machine == EM_IAMCU
16474               || elf_header.e_machine == EM_386)
16475             {
16476               switch (type)
16477                 {
16478                 case GNU_PROPERTY_X86_ISA_1_USED:
16479                   printf ("x86 ISA used: ");
16480                   if (datasz != 4)
16481                     printf (_("<corrupt length: %#x> "), datasz);
16482                   else
16483                     decode_x86_isa (byte_get (ptr, 4));
16484                   goto next;
16485
16486                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16487                   printf ("x86 ISA needed: ");
16488                   if (datasz != 4)
16489                     printf (_("<corrupt length: %#x> "), datasz);
16490                   else
16491                     decode_x86_isa (byte_get (ptr, 4));
16492                   goto next;
16493
16494                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16495                   printf ("x86 feature: ");
16496                   if (datasz != 4)
16497                     printf (_("<corrupt length: %#x> "), datasz);
16498                   else
16499                     decode_x86_feature (type, byte_get (ptr, 4));
16500                   goto next;
16501
16502                 default:
16503                   break;
16504                 }
16505             }
16506         }
16507       else
16508         {
16509           switch (type)
16510             {
16511             case GNU_PROPERTY_STACK_SIZE:
16512               printf (_("stack size: "));
16513               if (datasz != size)
16514                 printf (_("<corrupt length: %#x> "), datasz);
16515               else
16516                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16517               goto next;
16518
16519             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16520               printf ("no copy on protected ");
16521               if (datasz)
16522                 printf (_("<corrupt length: %#x> "), datasz);
16523               goto next;
16524
16525             default:
16526               break;
16527             }
16528         }
16529
16530       if (type < GNU_PROPERTY_LOPROC)
16531         printf (_("<unknown type %#x data: "), type);
16532       else if (type < GNU_PROPERTY_LOUSER)
16533         printf (_("<procesor-specific type %#x data: "), type);
16534       else
16535         printf (_("<application-specific type %#x data: "), type);
16536       for (j = 0; j < datasz; ++j)
16537         printf ("%02x ", ptr[j] & 0xff);
16538       printf (">");
16539
16540 next:
16541       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16542       if (ptr == ptr_end)
16543         break;
16544       else
16545         {
16546           if (do_wide)
16547             printf (", ");
16548           else
16549             printf ("\n\t");
16550         }
16551
16552       if (ptr > (ptr_end - 8))
16553         {
16554           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16555           break;
16556         }
16557     }
16558
16559   printf ("\n");
16560 }
16561
16562 static bfd_boolean
16563 print_gnu_note (Elf_Internal_Note *pnote)
16564 {
16565   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16566   switch (pnote->type)
16567     {
16568     case NT_GNU_BUILD_ID:
16569       {
16570         unsigned long i;
16571
16572         printf (_("    Build ID: "));
16573         for (i = 0; i < pnote->descsz; ++i)
16574           printf ("%02x", pnote->descdata[i] & 0xff);
16575         printf ("\n");
16576       }
16577       break;
16578
16579     case NT_GNU_ABI_TAG:
16580       {
16581         unsigned long os, major, minor, subminor;
16582         const char *osname;
16583
16584         /* PR 17531: file: 030-599401-0.004.  */
16585         if (pnote->descsz < 16)
16586           {
16587             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16588             break;
16589           }
16590
16591         os = byte_get ((unsigned char *) pnote->descdata, 4);
16592         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16593         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16594         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16595
16596         switch (os)
16597           {
16598           case GNU_ABI_TAG_LINUX:
16599             osname = "Linux";
16600             break;
16601           case GNU_ABI_TAG_HURD:
16602             osname = "Hurd";
16603             break;
16604           case GNU_ABI_TAG_SOLARIS:
16605             osname = "Solaris";
16606             break;
16607           case GNU_ABI_TAG_FREEBSD:
16608             osname = "FreeBSD";
16609             break;
16610           case GNU_ABI_TAG_NETBSD:
16611             osname = "NetBSD";
16612             break;
16613           case GNU_ABI_TAG_SYLLABLE:
16614             osname = "Syllable";
16615             break;
16616           case GNU_ABI_TAG_NACL:
16617             osname = "NaCl";
16618             break;
16619           default:
16620             osname = "Unknown";
16621             break;
16622           }
16623
16624         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16625                 major, minor, subminor);
16626       }
16627       break;
16628
16629     case NT_GNU_GOLD_VERSION:
16630       {
16631         unsigned long i;
16632
16633         printf (_("    Version: "));
16634         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16635           printf ("%c", pnote->descdata[i]);
16636         printf ("\n");
16637       }
16638       break;
16639
16640     case NT_GNU_HWCAP:
16641       {
16642         unsigned long num_entries, mask;
16643
16644         /* Hardware capabilities information.  Word 0 is the number of entries.
16645            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16646            is a series of entries, where each entry is a single byte followed
16647            by a nul terminated string.  The byte gives the bit number to test
16648            if enabled in the bitmask.  */
16649         printf (_("      Hardware Capabilities: "));
16650         if (pnote->descsz < 8)
16651           {
16652             error (_("<corrupt GNU_HWCAP>\n"));
16653             return FALSE;
16654           }
16655         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16656         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16657         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16658         /* FIXME: Add code to display the entries... */
16659       }
16660       break;
16661
16662     case NT_GNU_PROPERTY_TYPE_0:
16663       print_gnu_property_note (pnote);
16664       break;
16665
16666     default:
16667       /* Handle unrecognised types.  An error message should have already been
16668          created by get_gnu_elf_note_type(), so all that we need to do is to
16669          display the data.  */
16670       {
16671         unsigned long i;
16672
16673         printf (_("    Description data: "));
16674         for (i = 0; i < pnote->descsz; ++i)
16675           printf ("%02x ", pnote->descdata[i] & 0xff);
16676         printf ("\n");
16677       }
16678       break;
16679     }
16680
16681   return TRUE;
16682 }
16683
16684 static const char *
16685 get_v850_elf_note_type (enum v850_notes n_type)
16686 {
16687   static char buff[64];
16688
16689   switch (n_type)
16690     {
16691     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16692     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16693     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16694     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16695     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16696     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16697     default:
16698       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16699       return buff;
16700     }
16701 }
16702
16703 static bfd_boolean
16704 print_v850_note (Elf_Internal_Note * pnote)
16705 {
16706   unsigned int val;
16707
16708   if (pnote->descsz != 4)
16709     return FALSE;
16710
16711   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16712
16713   if (val == 0)
16714     {
16715       printf (_("not set\n"));
16716       return TRUE;
16717     }
16718
16719   switch (pnote->type)
16720     {
16721     case V850_NOTE_ALIGNMENT:
16722       switch (val)
16723         {
16724         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16725         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16726         }
16727       break;
16728
16729     case V850_NOTE_DATA_SIZE:
16730       switch (val)
16731         {
16732         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16733         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16734         }
16735       break;
16736
16737     case V850_NOTE_FPU_INFO:
16738       switch (val)
16739         {
16740         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16741         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16742         }
16743       break;
16744
16745     case V850_NOTE_MMU_INFO:
16746     case V850_NOTE_CACHE_INFO:
16747     case V850_NOTE_SIMD_INFO:
16748       if (val == EF_RH850_SIMD)
16749         {
16750           printf (_("yes\n"));
16751           return TRUE;
16752         }
16753       break;
16754
16755     default:
16756       /* An 'unknown note type' message will already have been displayed.  */
16757       break;
16758     }
16759
16760   printf (_("unknown value: %x\n"), val);
16761   return FALSE;
16762 }
16763
16764 static bfd_boolean
16765 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16766 {
16767   unsigned int version;
16768
16769   switch (pnote->type)
16770     {
16771     case NT_NETBSD_IDENT:
16772       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16773       if ((version / 10000) % 100)
16774         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16775                 version, version / 100000000, (version / 1000000) % 100,
16776                 (version / 10000) % 100 > 26 ? "Z" : "",
16777                 'A' + (version / 10000) % 26);
16778       else
16779         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16780                 version, version / 100000000, (version / 1000000) % 100,
16781                 (version / 100) % 100);
16782       return TRUE;
16783
16784     case NT_NETBSD_MARCH:
16785       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16786               pnote->descdata);
16787       return TRUE;
16788
16789     default:
16790       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16791               pnote->type);
16792       return FALSE;
16793     }
16794 }
16795
16796 static const char *
16797 get_freebsd_elfcore_note_type (unsigned e_type)
16798 {
16799   switch (e_type)
16800     {
16801     case NT_FREEBSD_THRMISC:
16802       return _("NT_THRMISC (thrmisc structure)");
16803     case NT_FREEBSD_PROCSTAT_PROC:
16804       return _("NT_PROCSTAT_PROC (proc data)");
16805     case NT_FREEBSD_PROCSTAT_FILES:
16806       return _("NT_PROCSTAT_FILES (files data)");
16807     case NT_FREEBSD_PROCSTAT_VMMAP:
16808       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16809     case NT_FREEBSD_PROCSTAT_GROUPS:
16810       return _("NT_PROCSTAT_GROUPS (groups data)");
16811     case NT_FREEBSD_PROCSTAT_UMASK:
16812       return _("NT_PROCSTAT_UMASK (umask data)");
16813     case NT_FREEBSD_PROCSTAT_RLIMIT:
16814       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16815     case NT_FREEBSD_PROCSTAT_OSREL:
16816       return _("NT_PROCSTAT_OSREL (osreldate data)");
16817     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16818       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16819     case NT_FREEBSD_PROCSTAT_AUXV:
16820       return _("NT_PROCSTAT_AUXV (auxv data)");
16821     case NT_FREEBSD_PTLWPINFO:
16822       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16823     }
16824   return get_note_type (e_type);
16825 }
16826
16827 static const char *
16828 get_netbsd_elfcore_note_type (unsigned e_type)
16829 {
16830   static char buff[64];
16831
16832   if (e_type == NT_NETBSDCORE_PROCINFO)
16833     {
16834       /* NetBSD core "procinfo" structure.  */
16835       return _("NetBSD procinfo structure");
16836     }
16837
16838   /* As of Jan 2002 there are no other machine-independent notes
16839      defined for NetBSD core files.  If the note type is less
16840      than the start of the machine-dependent note types, we don't
16841      understand it.  */
16842
16843   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16844     {
16845       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16846       return buff;
16847     }
16848
16849   switch (elf_header.e_machine)
16850     {
16851     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16852        and PT_GETFPREGS == mach+2.  */
16853
16854     case EM_OLD_ALPHA:
16855     case EM_ALPHA:
16856     case EM_SPARC:
16857     case EM_SPARC32PLUS:
16858     case EM_SPARCV9:
16859       switch (e_type)
16860         {
16861         case NT_NETBSDCORE_FIRSTMACH + 0:
16862           return _("PT_GETREGS (reg structure)");
16863         case NT_NETBSDCORE_FIRSTMACH + 2:
16864           return _("PT_GETFPREGS (fpreg structure)");
16865         default:
16866           break;
16867         }
16868       break;
16869
16870     /* On all other arch's, PT_GETREGS == mach+1 and
16871        PT_GETFPREGS == mach+3.  */
16872     default:
16873       switch (e_type)
16874         {
16875         case NT_NETBSDCORE_FIRSTMACH + 1:
16876           return _("PT_GETREGS (reg structure)");
16877         case NT_NETBSDCORE_FIRSTMACH + 3:
16878           return _("PT_GETFPREGS (fpreg structure)");
16879         default:
16880           break;
16881         }
16882     }
16883
16884   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16885             e_type - NT_NETBSDCORE_FIRSTMACH);
16886   return buff;
16887 }
16888
16889 static const char *
16890 get_stapsdt_note_type (unsigned e_type)
16891 {
16892   static char buff[64];
16893
16894   switch (e_type)
16895     {
16896     case NT_STAPSDT:
16897       return _("NT_STAPSDT (SystemTap probe descriptors)");
16898
16899     default:
16900       break;
16901     }
16902
16903   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16904   return buff;
16905 }
16906
16907 static bfd_boolean
16908 print_stapsdt_note (Elf_Internal_Note *pnote)
16909 {
16910   int addr_size = is_32bit_elf ? 4 : 8;
16911   char *data = pnote->descdata;
16912   char *data_end = pnote->descdata + pnote->descsz;
16913   bfd_vma pc, base_addr, semaphore;
16914   char *provider, *probe, *arg_fmt;
16915
16916   pc = byte_get ((unsigned char *) data, addr_size);
16917   data += addr_size;
16918   base_addr = byte_get ((unsigned char *) data, addr_size);
16919   data += addr_size;
16920   semaphore = byte_get ((unsigned char *) data, addr_size);
16921   data += addr_size;
16922
16923   provider = data;
16924   data += strlen (data) + 1;
16925   probe = data;
16926   data += strlen (data) + 1;
16927   arg_fmt = data;
16928   data += strlen (data) + 1;
16929
16930   printf (_("    Provider: %s\n"), provider);
16931   printf (_("    Name: %s\n"), probe);
16932   printf (_("    Location: "));
16933   print_vma (pc, FULL_HEX);
16934   printf (_(", Base: "));
16935   print_vma (base_addr, FULL_HEX);
16936   printf (_(", Semaphore: "));
16937   print_vma (semaphore, FULL_HEX);
16938   printf ("\n");
16939   printf (_("    Arguments: %s\n"), arg_fmt);
16940
16941   return data == data_end;
16942 }
16943
16944 static const char *
16945 get_ia64_vms_note_type (unsigned e_type)
16946 {
16947   static char buff[64];
16948
16949   switch (e_type)
16950     {
16951     case NT_VMS_MHD:
16952       return _("NT_VMS_MHD (module header)");
16953     case NT_VMS_LNM:
16954       return _("NT_VMS_LNM (language name)");
16955     case NT_VMS_SRC:
16956       return _("NT_VMS_SRC (source files)");
16957     case NT_VMS_TITLE:
16958       return "NT_VMS_TITLE";
16959     case NT_VMS_EIDC:
16960       return _("NT_VMS_EIDC (consistency check)");
16961     case NT_VMS_FPMODE:
16962       return _("NT_VMS_FPMODE (FP mode)");
16963     case NT_VMS_LINKTIME:
16964       return "NT_VMS_LINKTIME";
16965     case NT_VMS_IMGNAM:
16966       return _("NT_VMS_IMGNAM (image name)");
16967     case NT_VMS_IMGID:
16968       return _("NT_VMS_IMGID (image id)");
16969     case NT_VMS_LINKID:
16970       return _("NT_VMS_LINKID (link id)");
16971     case NT_VMS_IMGBID:
16972       return _("NT_VMS_IMGBID (build id)");
16973     case NT_VMS_GSTNAM:
16974       return _("NT_VMS_GSTNAM (sym table name)");
16975     case NT_VMS_ORIG_DYN:
16976       return "NT_VMS_ORIG_DYN";
16977     case NT_VMS_PATCHTIME:
16978       return "NT_VMS_PATCHTIME";
16979     default:
16980       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16981       return buff;
16982     }
16983 }
16984
16985 static bfd_boolean
16986 print_ia64_vms_note (Elf_Internal_Note * pnote)
16987 {
16988   switch (pnote->type)
16989     {
16990     case NT_VMS_MHD:
16991       if (pnote->descsz > 36)
16992         {
16993           size_t l = strlen (pnote->descdata + 34);
16994           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16995           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16996           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16997           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16998         }
16999       else
17000         printf (_("    Invalid size\n"));
17001       break;
17002     case NT_VMS_LNM:
17003       printf (_("   Language: %s\n"), pnote->descdata);
17004       break;
17005 #ifdef BFD64
17006     case NT_VMS_FPMODE:
17007       printf (_("   Floating Point mode: "));
17008       printf ("0x%016" BFD_VMA_FMT "x\n",
17009               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17010       break;
17011     case NT_VMS_LINKTIME:
17012       printf (_("   Link time: "));
17013       print_vms_time
17014         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17015       printf ("\n");
17016       break;
17017     case NT_VMS_PATCHTIME:
17018       printf (_("   Patch time: "));
17019       print_vms_time
17020         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17021       printf ("\n");
17022       break;
17023     case NT_VMS_ORIG_DYN:
17024       printf (_("   Major id: %u,  minor id: %u\n"),
17025               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17026               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17027       printf (_("   Last modified  : "));
17028       print_vms_time
17029         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17030       printf (_("\n   Link flags  : "));
17031       printf ("0x%016" BFD_VMA_FMT "x\n",
17032               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17033       printf (_("   Header flags: 0x%08x\n"),
17034               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17035       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17036       break;
17037 #endif
17038     case NT_VMS_IMGNAM:
17039       printf (_("    Image name: %s\n"), pnote->descdata);
17040       break;
17041     case NT_VMS_GSTNAM:
17042       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17043       break;
17044     case NT_VMS_IMGID:
17045       printf (_("    Image id: %s\n"), pnote->descdata);
17046       break;
17047     case NT_VMS_LINKID:
17048       printf (_("    Linker id: %s\n"), pnote->descdata);
17049       break;
17050     default:
17051       return FALSE;
17052     }
17053   return TRUE;
17054 }
17055
17056 /* Print the name of the symbol associated with a build attribute
17057    that is attached to address OFFSET.  */
17058
17059 static bfd_boolean
17060 print_symbol_for_build_attribute (FILE *         file,
17061                                   unsigned long  offset,
17062                                   bfd_boolean    is_open_attr)
17063 {
17064   static FILE *             saved_file = NULL;
17065   static char *             strtab;
17066   static unsigned long      strtablen;
17067   static Elf_Internal_Sym * symtab;
17068   static unsigned long      nsyms;
17069   Elf_Internal_Sym *        saved_sym = NULL;
17070   Elf_Internal_Sym *        sym;
17071
17072   if (section_headers != NULL
17073       && (saved_file == NULL || file != saved_file))
17074     {
17075       Elf_Internal_Shdr * symsec;
17076
17077       /* Load the symbol and string sections.  */
17078       for (symsec = section_headers;
17079            symsec < section_headers + elf_header.e_shnum;
17080            symsec ++)
17081         {
17082           if (symsec->sh_type == SHT_SYMTAB)
17083             {
17084               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17085
17086               if (symsec->sh_link < elf_header.e_shnum)
17087                 {
17088                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17089
17090                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17091                                               1, strtab_sec->sh_size,
17092                                               _("string table"));
17093                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17094                 }
17095             }
17096         }
17097       saved_file = file;
17098     }
17099
17100   if (symtab == NULL || strtab == NULL)
17101     {
17102       printf ("\n");
17103       return FALSE;
17104     }
17105
17106   /* Find a symbol whose value matches offset.  */
17107   for (sym = symtab; sym < symtab + nsyms; sym ++)
17108     if (sym->st_value == offset)
17109       {
17110         if (sym->st_name >= strtablen)
17111           /* Huh ?  This should not happen.  */
17112           continue;
17113
17114         if (strtab[sym->st_name] == 0)
17115           continue;
17116
17117         if (is_open_attr)
17118           {
17119             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17120                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17121                FUNC symbols entirely.  */
17122             switch (ELF_ST_TYPE (sym->st_info))
17123               {
17124               case STT_FILE:
17125                 saved_sym = sym;
17126                 /* We can stop searching now.  */
17127                 sym = symtab + nsyms;
17128                 continue;
17129
17130               case STT_OBJECT:
17131                 saved_sym = sym;
17132                 continue;
17133
17134               case STT_FUNC:
17135                 /* Ignore function symbols.  */
17136                 continue;
17137
17138               default:
17139                 break;
17140               }
17141
17142             switch (ELF_ST_BIND (sym->st_info))
17143               {
17144               case STB_GLOBAL:
17145                 if (saved_sym == NULL
17146                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17147                   saved_sym = sym;
17148                 break;
17149
17150               case STB_LOCAL:
17151                 if (saved_sym == NULL)
17152                   saved_sym = sym;
17153                 break;
17154
17155               default:
17156                 break;
17157               }
17158           }
17159         else
17160           {
17161             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17162               continue;
17163
17164             saved_sym = sym;
17165             break;
17166           }
17167       }
17168
17169   printf (" (%s: %s)\n",
17170           is_open_attr ? _("file") : _("func"),
17171           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17172   return TRUE;
17173 }
17174
17175 static bfd_boolean
17176 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17177                                        FILE *              file)
17178 {
17179   static unsigned long global_offset = 0;
17180   unsigned long        offset;
17181   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17182   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17183
17184   if (pnote->descsz == 0)
17185     {
17186       if (is_open_attr)
17187         {
17188           printf (_("    Applies from offset %#lx\n"), global_offset);
17189           return TRUE;
17190         }
17191       else
17192         {
17193           printf (_("    Applies to func at %#lx"), global_offset);
17194           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17195         }
17196     }
17197
17198   if (pnote->descsz != desc_size)
17199     {
17200       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17201       printf (_("    <invalid descsz>"));
17202       return FALSE;
17203     }
17204
17205   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17206
17207   if (is_open_attr)
17208     {
17209       printf (_("    Applies from offset %#lx"), offset);
17210       global_offset = offset;
17211     }
17212   else
17213     {
17214       printf (_("    Applies to func at %#lx"), offset);
17215     }
17216
17217   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17218 }
17219
17220 static bfd_boolean
17221 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17222 {
17223   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17224   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17225   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17226   char         name_type;
17227   char         name_attribute;
17228   const char * expected_types;
17229   const char * name = pnote->namedata;
17230   const char * text;
17231   signed int   left;
17232
17233   if (name == NULL || pnote->namesz < 2)
17234     {
17235       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17236       print_symbol (-20, _("  <corrupt name>"));
17237       return FALSE;
17238     }
17239
17240   left = 20;
17241
17242   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17243   if (name[0] == 'G' && name[1] == 'A')
17244     {
17245       printf ("GA");
17246       name += 2;
17247       left -= 2;
17248     }
17249
17250   switch ((name_type = * name))
17251     {
17252     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17253     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17254     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17255     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17256       printf ("%c", * name);
17257       left --;
17258       break;
17259     default:
17260       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17261       print_symbol (-20, _("<unknown name type>"));
17262       return FALSE;
17263     }
17264
17265   ++ name;
17266   text = NULL;
17267
17268   switch ((name_attribute = * name))
17269     {
17270     case GNU_BUILD_ATTRIBUTE_VERSION:
17271       text = _("<version>");
17272       expected_types = string_expected;
17273       ++ name;
17274       break;
17275     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17276       text = _("<stack prot>");
17277       expected_types = "!+*";
17278       ++ name;
17279       break;
17280     case GNU_BUILD_ATTRIBUTE_RELRO:
17281       text = _("<relro>");
17282       expected_types = bool_expected;
17283       ++ name;
17284       break;
17285     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17286       text = _("<stack size>");
17287       expected_types = number_expected;
17288       ++ name;
17289       break;
17290     case GNU_BUILD_ATTRIBUTE_TOOL:
17291       text = _("<tool>");
17292       expected_types = string_expected;
17293       ++ name;
17294       break;
17295     case GNU_BUILD_ATTRIBUTE_ABI:
17296       text = _("<ABI>");
17297       expected_types = "$*";
17298       ++ name;
17299       break;
17300     case GNU_BUILD_ATTRIBUTE_PIC:
17301       text = _("<PIC>");
17302       expected_types = number_expected;
17303       ++ name;
17304       break;
17305     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17306       text = _("<short enum>");
17307       expected_types = bool_expected;
17308       ++ name;
17309       break;
17310     default:
17311       if (ISPRINT (* name))
17312         {
17313           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17314
17315           if (len > left && ! do_wide)
17316             len = left;
17317           printf ("%.*s:", len, name);
17318           left -= len;
17319           name += len;
17320         }
17321       else
17322         {
17323           static char tmpbuf [128];
17324
17325           error (_("unrecognised byte in name field: %d\n"), * name);
17326           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17327           text = tmpbuf;
17328           name ++;
17329         }
17330       expected_types = "*$!+";
17331       break;
17332     }
17333
17334   if (text)
17335     left -= printf ("%s", text);
17336
17337   if (strchr (expected_types, name_type) == NULL)
17338     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17339
17340   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17341     {
17342       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17343              (unsigned long) pnote->namesz,
17344              (long) (name - pnote->namedata));
17345       return FALSE;
17346     }
17347
17348   if (left < 1 && ! do_wide)
17349     return TRUE;
17350
17351   switch (name_type)
17352     {
17353     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17354       {
17355         unsigned int        bytes;
17356         unsigned long long  val = 0;
17357         unsigned int        shift = 0;
17358         char *              decoded = NULL;
17359
17360         bytes = pnote->namesz - (name - pnote->namedata);
17361         if (bytes > 0)
17362           /* The -1 is because the name field is always 0 terminated, and we
17363              want to be able to ensure that the shift in the while loop below
17364              will not overflow.  */
17365           -- bytes;
17366
17367         if (bytes > sizeof (val))
17368           {
17369             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17370                      pnote->namesz, name, pnote->namedata);
17371             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17372                    bytes);
17373             bytes = sizeof (val);
17374           }
17375         /* We do not bother to warn if bytes == 0 as this can
17376            happen with some early versions of the gcc plugin.  */
17377
17378         while (bytes --)
17379           {
17380             unsigned long byte = (* name ++) & 0xff;
17381
17382             val |= byte << shift;
17383             shift += 8;
17384           }
17385
17386         switch (name_attribute)
17387           {
17388           case GNU_BUILD_ATTRIBUTE_PIC:
17389             switch (val)
17390               {
17391               case 0: decoded = "static"; break;
17392               case 1: decoded = "pic"; break;
17393               case 2: decoded = "PIC"; break;
17394               case 3: decoded = "pie"; break;
17395               case 4: decoded = "PIE"; break;
17396               default: break;
17397               }
17398             break;
17399           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17400             switch (val)
17401               {
17402                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17403               case 0: decoded = "off"; break;
17404               case 1: decoded = "on"; break;
17405               case 2: decoded = "all"; break;
17406               case 3: decoded = "strong"; break;
17407               case 4: decoded = "explicit"; break;
17408               default: break;
17409               }
17410             break;
17411           default:
17412             break;
17413           }
17414
17415         if (decoded != NULL)
17416           {
17417             print_symbol (-left, decoded);
17418             left = 0;
17419           }
17420         else if (val == 0)
17421           {
17422             printf ("0x0");
17423             left -= 3;
17424           }
17425         else
17426           {
17427             if (do_wide)
17428               left -= printf ("0x%llx", val);
17429             else
17430               left -= printf ("0x%-.*llx", left, val);
17431           }
17432       }
17433       break;
17434     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17435       left -= print_symbol (- left, name);
17436       break;
17437     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17438       left -= print_symbol (- left, "true");
17439       break;
17440     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17441       left -= print_symbol (- left, "false");
17442       break;
17443     }
17444
17445   if (do_wide && left > 0)
17446     printf ("%-*s", left, " ");
17447
17448   return TRUE;
17449 }
17450
17451 /* Note that by the ELF standard, the name field is already null byte
17452    terminated, and namesz includes the terminating null byte.
17453    I.E. the value of namesz for the name "FSF" is 4.
17454
17455    If the value of namesz is zero, there is no name present.  */
17456
17457 static bfd_boolean
17458 process_note (Elf_Internal_Note *  pnote,
17459               FILE *               file)
17460 {
17461   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17462   const char * nt;
17463
17464   if (pnote->namesz == 0)
17465     /* If there is no note name, then use the default set of
17466        note type strings.  */
17467     nt = get_note_type (pnote->type);
17468
17469   else if (const_strneq (pnote->namedata, "GNU"))
17470     /* GNU-specific object file notes.  */
17471     nt = get_gnu_elf_note_type (pnote->type);
17472
17473   else if (const_strneq (pnote->namedata, "FreeBSD"))
17474     /* FreeBSD-specific core file notes.  */
17475     nt = get_freebsd_elfcore_note_type (pnote->type);
17476
17477   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17478     /* NetBSD-specific core file notes.  */
17479     nt = get_netbsd_elfcore_note_type (pnote->type);
17480
17481   else if (const_strneq (pnote->namedata, "NetBSD"))
17482     /* NetBSD-specific core file notes.  */
17483     return process_netbsd_elf_note (pnote);
17484
17485   else if (strneq (pnote->namedata, "SPU/", 4))
17486     {
17487       /* SPU-specific core file notes.  */
17488       nt = pnote->namedata + 4;
17489       name = "SPU";
17490     }
17491
17492   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17493     /* VMS/ia64-specific file notes.  */
17494     nt = get_ia64_vms_note_type (pnote->type);
17495
17496   else if (const_strneq (pnote->namedata, "stapsdt"))
17497     nt = get_stapsdt_note_type (pnote->type);
17498
17499   else
17500     /* Don't recognize this note name; just use the default set of
17501        note type strings.  */
17502     nt = get_note_type (pnote->type);
17503
17504   printf ("  ");
17505
17506   if (((const_strneq (pnote->namedata, "GA")
17507         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17508        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17509       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17510           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17511     print_gnu_build_attribute_name (pnote);
17512   else
17513     print_symbol (-20, name);
17514
17515   if (do_wide)
17516     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17517   else
17518     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17519
17520   if (const_strneq (pnote->namedata, "IPF/VMS"))
17521     return print_ia64_vms_note (pnote);
17522   else if (const_strneq (pnote->namedata, "GNU"))
17523     return print_gnu_note (pnote);
17524   else if (const_strneq (pnote->namedata, "stapsdt"))
17525     return print_stapsdt_note (pnote);
17526   else if (const_strneq (pnote->namedata, "CORE"))
17527     return print_core_note (pnote);
17528   else if (((const_strneq (pnote->namedata, "GA")
17529              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17530             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17531            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17532                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17533     return print_gnu_build_attribute_description (pnote, file);
17534
17535   if (pnote->descsz)
17536     {
17537       unsigned long i;
17538
17539       printf (_("   description data: "));
17540       for (i = 0; i < pnote->descsz; i++)
17541         printf ("%02x ", pnote->descdata[i]);
17542       if (!do_wide)
17543         printf ("\n");
17544     }
17545
17546   if (do_wide)
17547     printf ("\n");
17548
17549   return TRUE;
17550 }
17551
17552 static bfd_boolean
17553 process_notes_at (FILE *              file,
17554                   Elf_Internal_Shdr * section,
17555                   bfd_vma             offset,
17556                   bfd_vma             length)
17557 {
17558   Elf_External_Note * pnotes;
17559   Elf_External_Note * external;
17560   char * end;
17561   bfd_boolean res = TRUE;
17562
17563   if (length <= 0)
17564     return FALSE;
17565
17566   if (section)
17567     {
17568       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17569       if (pnotes)
17570         {
17571           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17572             return FALSE;
17573         }
17574     }
17575   else
17576     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17577                                              _("notes"));
17578   if (pnotes == NULL)
17579     return FALSE;
17580
17581   external = pnotes;
17582
17583   if (section)
17584     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17585   else
17586     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17587             (unsigned long) offset, (unsigned long) length);
17588
17589   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17590
17591   end = (char *) pnotes + length;
17592   while ((char *) external < end)
17593     {
17594       Elf_Internal_Note inote;
17595       size_t min_notesz;
17596       char *next;
17597       char * temp = NULL;
17598       size_t data_remaining = end - (char *) external;
17599
17600       if (!is_ia64_vms ())
17601         {
17602           /* PR binutils/15191
17603              Make sure that there is enough data to read.  */
17604           min_notesz = offsetof (Elf_External_Note, name);
17605           if (data_remaining < min_notesz)
17606             {
17607               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17608                     (int) data_remaining);
17609               break;
17610             }
17611           inote.type     = BYTE_GET (external->type);
17612           inote.namesz   = BYTE_GET (external->namesz);
17613           inote.namedata = external->name;
17614           inote.descsz   = BYTE_GET (external->descsz);
17615           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17616           /* PR 17531: file: 3443835e.  */
17617           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17618             {
17619               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17620                     inote.namesz, (long)(end - inote.namedata));
17621               inote.descdata = inote.namedata;
17622               inote.namesz   = 0;
17623             }
17624
17625           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17626           next = inote.descdata + align_power (inote.descsz, 2);
17627         }
17628       else
17629         {
17630           Elf64_External_VMS_Note *vms_external;
17631
17632           /* PR binutils/15191
17633              Make sure that there is enough data to read.  */
17634           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17635           if (data_remaining < min_notesz)
17636             {
17637               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17638                     (int) data_remaining);
17639               break;
17640             }
17641
17642           vms_external = (Elf64_External_VMS_Note *) external;
17643           inote.type     = BYTE_GET (vms_external->type);
17644           inote.namesz   = BYTE_GET (vms_external->namesz);
17645           inote.namedata = vms_external->name;
17646           inote.descsz   = BYTE_GET (vms_external->descsz);
17647           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17648           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17649           next = inote.descdata + align_power (inote.descsz, 3);
17650         }
17651
17652       if (inote.descdata < (char *) external + min_notesz
17653           || next < (char *) external + min_notesz
17654           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17655           || inote.namedata + inote.namesz < inote.namedata
17656           || inote.descdata + inote.descsz < inote.descdata
17657           || data_remaining < (size_t)(next - (char *) external))
17658         {
17659           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17660                 (unsigned long) ((char *) external - (char *) pnotes));
17661           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17662                 inote.type, inote.namesz, inote.descsz);
17663           break;
17664         }
17665
17666       external = (Elf_External_Note *) next;
17667
17668       /* Verify that name is null terminated.  It appears that at least
17669          one version of Linux (RedHat 6.0) generates corefiles that don't
17670          comply with the ELF spec by failing to include the null byte in
17671          namesz.  */
17672       if (inote.namedata[inote.namesz - 1] != '\0')
17673         {
17674           temp = (char *) malloc (inote.namesz + 1);
17675           if (temp == NULL)
17676             {
17677               error (_("Out of memory allocating space for inote name\n"));
17678               res = FALSE;
17679               break;
17680             }
17681
17682           memcpy (temp, inote.namedata, inote.namesz);
17683           temp[inote.namesz] = 0;
17684
17685           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17686           inote.namedata = temp;
17687         }
17688
17689       if (! process_note (& inote, file))
17690         res = FALSE;
17691
17692       if (temp != NULL)
17693         {
17694           free (temp);
17695           temp = NULL;
17696         }
17697     }
17698
17699   free (pnotes);
17700
17701   return res;
17702 }
17703
17704 static bfd_boolean
17705 process_corefile_note_segments (FILE * file)
17706 {
17707   Elf_Internal_Phdr * segment;
17708   unsigned int i;
17709   bfd_boolean res = TRUE;
17710
17711   if (! get_program_headers (file))
17712     return TRUE;
17713
17714   for (i = 0, segment = program_headers;
17715        i < elf_header.e_phnum;
17716        i++, segment++)
17717     {
17718       if (segment->p_type == PT_NOTE)
17719         if (! process_notes_at (file, NULL,
17720                                 (bfd_vma) segment->p_offset,
17721                                 (bfd_vma) segment->p_filesz))
17722           res = FALSE;
17723     }
17724
17725   return res;
17726 }
17727
17728 static bfd_boolean
17729 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17730 {
17731   Elf_External_Note * pnotes;
17732   Elf_External_Note * external;
17733   char * end;
17734   bfd_boolean res = TRUE;
17735
17736   if (length <= 0)
17737     return FALSE;
17738
17739   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17740                                            _("v850 notes"));
17741   if (pnotes == NULL)
17742     return FALSE;
17743
17744   external = pnotes;
17745   end = (char*) pnotes + length;
17746
17747   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17748           (unsigned long) offset, (unsigned long) length);
17749
17750   while ((char *) external + sizeof (Elf_External_Note) < end)
17751     {
17752       Elf_External_Note * next;
17753       Elf_Internal_Note inote;
17754
17755       inote.type     = BYTE_GET (external->type);
17756       inote.namesz   = BYTE_GET (external->namesz);
17757       inote.namedata = external->name;
17758       inote.descsz   = BYTE_GET (external->descsz);
17759       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17760       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17761
17762       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17763         {
17764           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17765           inote.descdata = inote.namedata;
17766           inote.namesz   = 0;
17767         }
17768
17769       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17770
17771       if (   ((char *) next > end)
17772           || ((char *) next <  (char *) pnotes))
17773         {
17774           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17775                 (unsigned long) ((char *) external - (char *) pnotes));
17776           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17777                 inote.type, inote.namesz, inote.descsz);
17778           break;
17779         }
17780
17781       external = next;
17782
17783       /* Prevent out-of-bounds indexing.  */
17784       if (   inote.namedata + inote.namesz > end
17785           || inote.namedata + inote.namesz < inote.namedata)
17786         {
17787           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17788                 (unsigned long) ((char *) external - (char *) pnotes));
17789           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17790                 inote.type, inote.namesz, inote.descsz);
17791           break;
17792         }
17793
17794       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17795
17796       if (! print_v850_note (& inote))
17797         {
17798           res = FALSE;
17799           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17800                   inote.namesz, inote.descsz);
17801         }
17802     }
17803
17804   free (pnotes);
17805
17806   return res;
17807 }
17808
17809 static bfd_boolean
17810 process_note_sections (FILE * file)
17811 {
17812   Elf_Internal_Shdr * section;
17813   unsigned long i;
17814   unsigned int n = 0;
17815   bfd_boolean res = TRUE;
17816
17817   for (i = 0, section = section_headers;
17818        i < elf_header.e_shnum && section != NULL;
17819        i++, section++)
17820     {
17821       if (section->sh_type == SHT_NOTE)
17822         {
17823           if (! process_notes_at (file, section,
17824                                   (bfd_vma) section->sh_offset,
17825                                   (bfd_vma) section->sh_size))
17826             res = FALSE;
17827           n++;
17828         }
17829
17830       if ((   elf_header.e_machine == EM_V800
17831            || elf_header.e_machine == EM_V850
17832            || elf_header.e_machine == EM_CYGNUS_V850)
17833           && section->sh_type == SHT_RENESAS_INFO)
17834         {
17835           if (! process_v850_notes (file,
17836                                     (bfd_vma) section->sh_offset,
17837                                     (bfd_vma) section->sh_size))
17838             res = FALSE;
17839           n++;
17840         }
17841     }
17842
17843   if (n == 0)
17844     /* Try processing NOTE segments instead.  */
17845     return process_corefile_note_segments (file);
17846
17847   return res;
17848 }
17849
17850 static bfd_boolean
17851 process_notes (FILE * file)
17852 {
17853   /* If we have not been asked to display the notes then do nothing.  */
17854   if (! do_notes)
17855     return TRUE;
17856
17857   if (elf_header.e_type != ET_CORE)
17858     return process_note_sections (file);
17859
17860   /* No program headers means no NOTE segment.  */
17861   if (elf_header.e_phnum > 0)
17862     return process_corefile_note_segments (file);
17863
17864   printf (_("No note segments present in the core file.\n"));
17865   return TRUE;
17866 }
17867
17868 static unsigned char *
17869 display_public_gnu_attributes (unsigned char * start,
17870                                const unsigned char * const end)
17871 {
17872   printf (_("  Unknown GNU attribute: %s\n"), start);
17873
17874   start += strnlen ((char *) start, end - start);
17875   display_raw_attribute (start, end);
17876
17877   return (unsigned char *) end;
17878 }
17879
17880 static unsigned char *
17881 display_generic_attribute (unsigned char * start,
17882                            unsigned int tag,
17883                            const unsigned char * const end)
17884 {
17885   if (tag == 0)
17886     return (unsigned char *) end;
17887
17888   return display_tag_value (tag, start, end);
17889 }
17890
17891 static bfd_boolean
17892 process_arch_specific (FILE * file)
17893 {
17894   if (! do_arch)
17895     return TRUE;
17896
17897   switch (elf_header.e_machine)
17898     {
17899     case EM_ARC:
17900     case EM_ARC_COMPACT:
17901     case EM_ARC_COMPACT2:
17902       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17903                                  display_arc_attribute,
17904                                  display_generic_attribute);
17905     case EM_ARM:
17906       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17907                                  display_arm_attribute,
17908                                  display_generic_attribute);
17909
17910     case EM_MIPS:
17911     case EM_MIPS_RS3_LE:
17912       return process_mips_specific (file);
17913
17914     case EM_MSP430:
17915      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17916                                  display_msp430x_attribute,
17917                                  display_generic_attribute);
17918
17919     case EM_NDS32:
17920       return process_nds32_specific (file);
17921
17922     case EM_PPC:
17923     case EM_PPC64:
17924       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17925                                  display_power_gnu_attribute);
17926
17927     case EM_S390:
17928     case EM_S390_OLD:
17929       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17930                                  display_s390_gnu_attribute);
17931
17932     case EM_SPARC:
17933     case EM_SPARC32PLUS:
17934     case EM_SPARCV9:
17935       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17936                                  display_sparc_gnu_attribute);
17937
17938     case EM_TI_C6000:
17939       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17940                                  display_tic6x_attribute,
17941                                  display_generic_attribute);
17942
17943     default:
17944       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17945                                  display_public_gnu_attributes,
17946                                  display_generic_attribute);
17947     }
17948 }
17949
17950 static bfd_boolean
17951 get_file_header (FILE * file)
17952 {
17953   /* Read in the identity array.  */
17954   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17955     return FALSE;
17956
17957   /* Determine how to read the rest of the header.  */
17958   switch (elf_header.e_ident[EI_DATA])
17959     {
17960     default:
17961     case ELFDATANONE:
17962     case ELFDATA2LSB:
17963       byte_get = byte_get_little_endian;
17964       byte_put = byte_put_little_endian;
17965       break;
17966     case ELFDATA2MSB:
17967       byte_get = byte_get_big_endian;
17968       byte_put = byte_put_big_endian;
17969       break;
17970     }
17971
17972   /* For now we only support 32 bit and 64 bit ELF files.  */
17973   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17974
17975   /* Read in the rest of the header.  */
17976   if (is_32bit_elf)
17977     {
17978       Elf32_External_Ehdr ehdr32;
17979
17980       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17981         return FALSE;
17982
17983       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17984       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17985       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17986       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17987       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17988       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17989       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17990       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17991       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17992       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17993       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17994       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17995       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17996     }
17997   else
17998     {
17999       Elf64_External_Ehdr ehdr64;
18000
18001       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18002          we will not be able to cope with the 64bit data found in
18003          64 ELF files.  Detect this now and abort before we start
18004          overwriting things.  */
18005       if (sizeof (bfd_vma) < 8)
18006         {
18007           error (_("This instance of readelf has been built without support for a\n\
18008 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18009           return FALSE;
18010         }
18011
18012       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18013         return FALSE;
18014
18015       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
18016       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18017       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
18018       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18019       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18020       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18021       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18022       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18023       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18024       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18025       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18026       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18027       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18028     }
18029
18030   if (elf_header.e_shoff)
18031     {
18032       /* There may be some extensions in the first section header.  Don't
18033          bomb if we can't read it.  */
18034       if (is_32bit_elf)
18035         get_32bit_section_headers (file, TRUE);
18036       else
18037         get_64bit_section_headers (file, TRUE);
18038     }
18039
18040   return TRUE;
18041 }
18042
18043 /* Process one ELF object file according to the command line options.
18044    This file may actually be stored in an archive.  The file is
18045    positioned at the start of the ELF object.  Returns TRUE if no
18046    problems were encountered, FALSE otherwise.  */
18047
18048 static bfd_boolean
18049 process_object (char * file_name, FILE * file)
18050 {
18051   unsigned int i;
18052   bfd_boolean res = TRUE;
18053
18054   if (! get_file_header (file))
18055     {
18056       error (_("%s: Failed to read file header\n"), file_name);
18057       return FALSE;
18058     }
18059
18060   /* Initialise per file variables.  */
18061   for (i = ARRAY_SIZE (version_info); i--;)
18062     version_info[i] = 0;
18063
18064   for (i = ARRAY_SIZE (dynamic_info); i--;)
18065     dynamic_info[i] = 0;
18066   dynamic_info_DT_GNU_HASH = 0;
18067
18068   /* Process the file.  */
18069   if (show_name)
18070     printf (_("\nFile: %s\n"), file_name);
18071
18072   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18073      Note we do this even if cmdline_dump_sects is empty because we
18074      must make sure that the dump_sets array is zeroed out before each
18075      object file is processed.  */
18076   if (num_dump_sects > num_cmdline_dump_sects)
18077     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18078
18079   if (num_cmdline_dump_sects > 0)
18080     {
18081       if (num_dump_sects == 0)
18082         /* A sneaky way of allocating the dump_sects array.  */
18083         request_dump_bynumber (num_cmdline_dump_sects, 0);
18084
18085       assert (num_dump_sects >= num_cmdline_dump_sects);
18086       memcpy (dump_sects, cmdline_dump_sects,
18087               num_cmdline_dump_sects * sizeof (* dump_sects));
18088     }
18089
18090   if (! process_file_header ())
18091     return FALSE;
18092
18093   if (! process_section_headers (file))
18094     {
18095       /* Without loaded section headers we cannot process lots of things.  */
18096       do_unwind = do_version = do_dump = do_arch = FALSE;
18097
18098       if (! do_using_dynamic)
18099         do_syms = do_dyn_syms = do_reloc = FALSE;
18100     }
18101
18102   if (! process_section_groups (file))
18103     /* Without loaded section groups we cannot process unwind.  */
18104     do_unwind = FALSE;
18105
18106   if (process_program_headers (file))
18107     process_dynamic_section (file);
18108   else
18109     res = FALSE;
18110
18111   if (! process_relocs (file))
18112     res = FALSE;
18113
18114   if (! process_unwind (file))
18115     res = FALSE;
18116
18117   if (! process_symbol_table (file))
18118     res = FALSE;
18119
18120   if (! process_syminfo (file))
18121     res = FALSE;
18122
18123   if (! process_version_sections (file))
18124     res = FALSE;
18125
18126   if (! process_section_contents (file))
18127     res = FALSE;
18128
18129   if (! process_notes (file))
18130     res = FALSE;
18131
18132   if (! process_gnu_liblist (file))
18133     res = FALSE;
18134
18135   if (! process_arch_specific (file))
18136     res = FALSE;
18137
18138   if (program_headers)
18139     {
18140       free (program_headers);
18141       program_headers = NULL;
18142     }
18143
18144   if (section_headers)
18145     {
18146       free (section_headers);
18147       section_headers = NULL;
18148     }
18149
18150   if (string_table)
18151     {
18152       free (string_table);
18153       string_table = NULL;
18154       string_table_length = 0;
18155     }
18156
18157   if (dynamic_strings)
18158     {
18159       free (dynamic_strings);
18160       dynamic_strings = NULL;
18161       dynamic_strings_length = 0;
18162     }
18163
18164   if (dynamic_symbols)
18165     {
18166       free (dynamic_symbols);
18167       dynamic_symbols = NULL;
18168       num_dynamic_syms = 0;
18169     }
18170
18171   if (dynamic_syminfo)
18172     {
18173       free (dynamic_syminfo);
18174       dynamic_syminfo = NULL;
18175     }
18176
18177   if (dynamic_section)
18178     {
18179       free (dynamic_section);
18180       dynamic_section = NULL;
18181     }
18182
18183   if (section_headers_groups)
18184     {
18185       free (section_headers_groups);
18186       section_headers_groups = NULL;
18187     }
18188
18189   if (section_groups)
18190     {
18191       struct group_list * g;
18192       struct group_list * next;
18193
18194       for (i = 0; i < group_count; i++)
18195         {
18196           for (g = section_groups [i].root; g != NULL; g = next)
18197             {
18198               next = g->next;
18199               free (g);
18200             }
18201         }
18202
18203       free (section_groups);
18204       section_groups = NULL;
18205     }
18206
18207   free_debug_memory ();
18208
18209   return res;
18210 }
18211
18212 /* Process an ELF archive.
18213    On entry the file is positioned just after the ARMAG string.
18214    Returns TRUE upon success, FALSE otherwise.  */
18215
18216 static bfd_boolean
18217 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18218 {
18219   struct archive_info arch;
18220   struct archive_info nested_arch;
18221   size_t got;
18222   bfd_boolean ret = TRUE;
18223
18224   show_name = TRUE;
18225
18226   /* The ARCH structure is used to hold information about this archive.  */
18227   arch.file_name = NULL;
18228   arch.file = NULL;
18229   arch.index_array = NULL;
18230   arch.sym_table = NULL;
18231   arch.longnames = NULL;
18232
18233   /* The NESTED_ARCH structure is used as a single-item cache of information
18234      about a nested archive (when members of a thin archive reside within
18235      another regular archive file).  */
18236   nested_arch.file_name = NULL;
18237   nested_arch.file = NULL;
18238   nested_arch.index_array = NULL;
18239   nested_arch.sym_table = NULL;
18240   nested_arch.longnames = NULL;
18241
18242   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18243     {
18244       ret = FALSE;
18245       goto out;
18246     }
18247
18248   if (do_archive_index)
18249     {
18250       if (arch.sym_table == NULL)
18251         error (_("%s: unable to dump the index as none was found\n"), file_name);
18252       else
18253         {
18254           unsigned long i, l;
18255           unsigned long current_pos;
18256
18257           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18258                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18259           current_pos = ftell (file);
18260
18261           for (i = l = 0; i < arch.index_num; i++)
18262             {
18263               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18264                 {
18265                   char * member_name;
18266
18267                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18268
18269                   if (member_name != NULL)
18270                     {
18271                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18272
18273                       if (qualified_name != NULL)
18274                         {
18275                           printf (_("Contents of binary %s at offset "), qualified_name);
18276                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18277                           putchar ('\n');
18278                           free (qualified_name);
18279                         }
18280                     }
18281                 }
18282
18283               if (l >= arch.sym_size)
18284                 {
18285                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18286                          file_name);
18287                   ret = FALSE;
18288                   break;
18289                 }
18290               /* PR 17531: file: 0b6630b2.  */
18291               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18292               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18293             }
18294
18295           if (arch.uses_64bit_indicies)
18296             l = (l + 7) & ~ 7;
18297           else
18298             l += l & 1;
18299
18300           if (l < arch.sym_size)
18301             {
18302               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18303                      file_name, arch.sym_size - l);
18304               ret = FALSE;
18305             }
18306
18307           if (fseek (file, current_pos, SEEK_SET) != 0)
18308             {
18309               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18310               ret = FALSE;
18311               goto out;
18312             }
18313         }
18314
18315       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18316           && !do_segments && !do_header && !do_dump && !do_version
18317           && !do_histogram && !do_debugging && !do_arch && !do_notes
18318           && !do_section_groups && !do_dyn_syms)
18319         {
18320           ret = TRUE; /* Archive index only.  */
18321           goto out;
18322         }
18323     }
18324
18325   while (1)
18326     {
18327       char * name;
18328       size_t namelen;
18329       char * qualified_name;
18330
18331       /* Read the next archive header.  */
18332       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18333         {
18334           error (_("%s: failed to seek to next archive header\n"), file_name);
18335           return FALSE;
18336         }
18337       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18338       if (got != sizeof arch.arhdr)
18339         {
18340           if (got == 0)
18341             break;
18342           error (_("%s: failed to read archive header\n"), file_name);
18343           ret = FALSE;
18344           break;
18345         }
18346       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18347         {
18348           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18349           ret = FALSE;
18350           break;
18351         }
18352
18353       arch.next_arhdr_offset += sizeof arch.arhdr;
18354
18355       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18356       if (archive_file_size & 01)
18357         ++archive_file_size;
18358
18359       name = get_archive_member_name (&arch, &nested_arch);
18360       if (name == NULL)
18361         {
18362           error (_("%s: bad archive file name\n"), file_name);
18363           ret = FALSE;
18364           break;
18365         }
18366       namelen = strlen (name);
18367
18368       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18369       if (qualified_name == NULL)
18370         {
18371           error (_("%s: bad archive file name\n"), file_name);
18372           ret = FALSE;
18373           break;
18374         }
18375
18376       if (is_thin_archive && arch.nested_member_origin == 0)
18377         {
18378           /* This is a proxy for an external member of a thin archive.  */
18379           FILE * member_file;
18380           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18381
18382           if (member_file_name == NULL)
18383             {
18384               ret = FALSE;
18385               break;
18386             }
18387
18388           member_file = fopen (member_file_name, "rb");
18389           if (member_file == NULL)
18390             {
18391               error (_("Input file '%s' is not readable.\n"), member_file_name);
18392               free (member_file_name);
18393               ret = FALSE;
18394               break;
18395             }
18396
18397           archive_file_offset = arch.nested_member_origin;
18398
18399           if (! process_object (qualified_name, member_file))
18400             ret = FALSE;
18401
18402           fclose (member_file);
18403           free (member_file_name);
18404         }
18405       else if (is_thin_archive)
18406         {
18407           /* PR 15140: Allow for corrupt thin archives.  */
18408           if (nested_arch.file == NULL)
18409             {
18410               error (_("%s: contains corrupt thin archive: %s\n"),
18411                      file_name, name);
18412               ret = FALSE;
18413               break;
18414             }
18415
18416           /* This is a proxy for a member of a nested archive.  */
18417           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18418
18419           /* The nested archive file will have been opened and setup by
18420              get_archive_member_name.  */
18421           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18422             {
18423               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18424               ret = FALSE;
18425               break;
18426             }
18427
18428           if (! process_object (qualified_name, nested_arch.file))
18429             ret = FALSE;
18430         }
18431       else
18432         {
18433           archive_file_offset = arch.next_arhdr_offset;
18434           arch.next_arhdr_offset += archive_file_size;
18435
18436           if (! process_object (qualified_name, file))
18437             ret = FALSE;
18438         }
18439
18440       if (dump_sects != NULL)
18441         {
18442           free (dump_sects);
18443           dump_sects = NULL;
18444           num_dump_sects = 0;
18445         }
18446
18447       free (qualified_name);
18448     }
18449
18450  out:
18451   if (nested_arch.file != NULL)
18452     fclose (nested_arch.file);
18453   release_archive (&nested_arch);
18454   release_archive (&arch);
18455
18456   return ret;
18457 }
18458
18459 static bfd_boolean
18460 process_file (char * file_name)
18461 {
18462   FILE * file;
18463   struct stat statbuf;
18464   char armag[SARMAG];
18465   bfd_boolean ret = TRUE;
18466
18467   if (stat (file_name, &statbuf) < 0)
18468     {
18469       if (errno == ENOENT)
18470         error (_("'%s': No such file\n"), file_name);
18471       else
18472         error (_("Could not locate '%s'.  System error message: %s\n"),
18473                file_name, strerror (errno));
18474       return FALSE;
18475     }
18476
18477   if (! S_ISREG (statbuf.st_mode))
18478     {
18479       error (_("'%s' is not an ordinary file\n"), file_name);
18480       return FALSE;
18481     }
18482
18483   file = fopen (file_name, "rb");
18484   if (file == NULL)
18485     {
18486       error (_("Input file '%s' is not readable.\n"), file_name);
18487       return FALSE;
18488     }
18489
18490   if (fread (armag, SARMAG, 1, file) != 1)
18491     {
18492       error (_("%s: Failed to read file's magic number\n"), file_name);
18493       fclose (file);
18494       return FALSE;
18495     }
18496
18497   current_file_size = (bfd_size_type) statbuf.st_size;
18498
18499   if (memcmp (armag, ARMAG, SARMAG) == 0)
18500     {
18501       if (! process_archive (file_name, file, FALSE))
18502         ret = FALSE;
18503     }
18504   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18505     {
18506       if ( ! process_archive (file_name, file, TRUE))
18507         ret = FALSE;
18508     }
18509   else
18510     {
18511       if (do_archive_index)
18512         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18513                file_name);
18514
18515       rewind (file);
18516       archive_file_size = archive_file_offset = 0;
18517
18518       if (! process_object (file_name, file))
18519         ret = FALSE;
18520     }
18521
18522   fclose (file);
18523   current_file_size = 0;
18524
18525   return ret;
18526 }
18527
18528 #ifdef SUPPORT_DISASSEMBLY
18529 /* Needed by the i386 disassembler.  For extra credit, someone could
18530    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18531    symbols.  */
18532
18533 void
18534 print_address (unsigned int addr, FILE * outfile)
18535 {
18536   fprintf (outfile,"0x%8.8x", addr);
18537 }
18538
18539 /* Needed by the i386 disassembler.  */
18540 void
18541 db_task_printsym (unsigned int addr)
18542 {
18543   print_address (addr, stderr);
18544 }
18545 #endif
18546
18547 int
18548 main (int argc, char ** argv)
18549 {
18550   int err;
18551
18552 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18553   setlocale (LC_MESSAGES, "");
18554 #endif
18555 #if defined (HAVE_SETLOCALE)
18556   setlocale (LC_CTYPE, "");
18557 #endif
18558   bindtextdomain (PACKAGE, LOCALEDIR);
18559   textdomain (PACKAGE);
18560
18561   expandargv (&argc, &argv);
18562
18563   parse_args (argc, argv);
18564
18565   if (num_dump_sects > 0)
18566     {
18567       /* Make a copy of the dump_sects array.  */
18568       cmdline_dump_sects = (dump_type *)
18569           malloc (num_dump_sects * sizeof (* dump_sects));
18570       if (cmdline_dump_sects == NULL)
18571         error (_("Out of memory allocating dump request table.\n"));
18572       else
18573         {
18574           memcpy (cmdline_dump_sects, dump_sects,
18575                   num_dump_sects * sizeof (* dump_sects));
18576           num_cmdline_dump_sects = num_dump_sects;
18577         }
18578     }
18579
18580   if (optind < (argc - 1))
18581     show_name = TRUE;
18582   else if (optind >= argc)
18583     {
18584       warn (_("Nothing to do.\n"));
18585       usage (stderr);
18586     }
18587
18588   err = FALSE;
18589   while (optind < argc)
18590     if (! process_file (argv[optind++]))
18591       err = TRUE;
18592
18593   if (dump_sects != NULL)
18594     free (dump_sects);
18595   if (cmdline_dump_sects != NULL)
18596     free (cmdline_dump_sects);
18597
18598   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18599 }