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 long idx;
10157             unsigned long cnt;
10158             unsigned long 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 long isum;
10191                 int j;
10192
10193                 vstart = ((char *) edefs) + idx;
10194                 if (vstart + sizeof (*edef) > endbuf)
10195                   break;
10196
10197                 edef = (Elf_External_Verdef *) vstart;
10198
10199                 ent.vd_version = BYTE_GET (edef->vd_version);
10200                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10201                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10202                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10203                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10204                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10205                 ent.vd_next    = BYTE_GET (edef->vd_next);
10206
10207                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10208                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10209
10210                 printf (_("  Index: %d  Cnt: %d  "),
10211                         ent.vd_ndx, ent.vd_cnt);
10212
10213                 /* Check for overflow.  */
10214                 if (vstart + sizeof (*eaux) > endbuf)
10215                   break;
10216                 if (ent.vd_aux > (size_t) (endbuf - (vstart + sizeof (*eaux))))
10217                   break;
10218
10219                 vstart += ent.vd_aux;
10220
10221                 eaux = (Elf_External_Verdaux *) vstart;
10222
10223                 aux.vda_name = BYTE_GET (eaux->vda_name);
10224                 aux.vda_next = BYTE_GET (eaux->vda_next);
10225
10226                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10227                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10228                 else
10229                   printf (_("Name index: %ld\n"), aux.vda_name);
10230
10231                 isum = idx + ent.vd_aux;
10232
10233                 for (j = 1; j < ent.vd_cnt; j++)
10234                   {
10235                     /* Check for overflow.  */
10236                     if (aux.vda_next > (size_t) (endbuf - vstart))
10237                       break;
10238
10239                     isum   += aux.vda_next;
10240                     vstart += aux.vda_next;
10241
10242                     eaux = (Elf_External_Verdaux *) vstart;
10243                     if (vstart + sizeof (*eaux) > endbuf)
10244                       break;
10245
10246                     aux.vda_name = BYTE_GET (eaux->vda_name);
10247                     aux.vda_next = BYTE_GET (eaux->vda_next);
10248
10249                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10250                       printf (_("  %#06lx: Parent %d: %s\n"),
10251                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10252                     else
10253                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10254                               isum, j, aux.vda_name);
10255                   }
10256
10257                 if (j < ent.vd_cnt)
10258                   printf (_("  Version def aux past end of section\n"));
10259
10260                 /* PR 17531:
10261                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10262                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10263                   break;
10264
10265                 idx += ent.vd_next;
10266               }
10267
10268             if (cnt < section->sh_info)
10269               printf (_("  Version definition past end of section\n"));
10270
10271             free (edefs);
10272           }
10273           break;
10274
10275         case SHT_GNU_verneed:
10276           {
10277             Elf_External_Verneed * eneed;
10278             unsigned long idx;
10279             unsigned long cnt;
10280             char * endbuf;
10281
10282             found = TRUE;
10283
10284             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10285                     printable_section_name (section), section->sh_info);
10286
10287             printf (_(" Addr: 0x"));
10288             printf_vma (section->sh_addr);
10289             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10290                     (unsigned long) section->sh_offset, section->sh_link,
10291                     printable_section_name_from_index (section->sh_link));
10292
10293             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10294                                                        section->sh_offset, 1,
10295                                                        section->sh_size,
10296                                                        _("Version Needs section"));
10297             if (!eneed)
10298               break;
10299             endbuf = (char *) eneed + section->sh_size;
10300
10301             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10302               {
10303                 Elf_External_Verneed * entry;
10304                 Elf_Internal_Verneed ent;
10305                 unsigned long isum;
10306                 int j;
10307                 char * vstart;
10308
10309                 vstart = ((char *) eneed) + idx;
10310                 if (vstart + sizeof (*entry) > endbuf)
10311                   break;
10312
10313                 entry = (Elf_External_Verneed *) vstart;
10314
10315                 ent.vn_version = BYTE_GET (entry->vn_version);
10316                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10317                 ent.vn_file    = BYTE_GET (entry->vn_file);
10318                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10319                 ent.vn_next    = BYTE_GET (entry->vn_next);
10320
10321                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10322
10323                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10324                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10325                 else
10326                   printf (_("  File: %lx"), ent.vn_file);
10327
10328                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10329
10330                 /* Check for overflow.  */
10331                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10332                   break;
10333                 vstart += ent.vn_aux;
10334
10335                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10336                   {
10337                     Elf_External_Vernaux * eaux;
10338                     Elf_Internal_Vernaux aux;
10339
10340                     if (vstart + sizeof (*eaux) > endbuf)
10341                       break;
10342                     eaux = (Elf_External_Vernaux *) vstart;
10343
10344                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10345                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10346                     aux.vna_other = BYTE_GET (eaux->vna_other);
10347                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10348                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10349
10350                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10351                       printf (_("  %#06lx:   Name: %s"),
10352                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10353                     else
10354                       printf (_("  %#06lx:   Name index: %lx"),
10355                               isum, aux.vna_name);
10356
10357                     printf (_("  Flags: %s  Version: %d\n"),
10358                             get_ver_flags (aux.vna_flags), aux.vna_other);
10359
10360                     /* Check for overflow.  */
10361                     if (aux.vna_next > (size_t) (endbuf - vstart)
10362                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10363                       {
10364                         warn (_("Invalid vna_next field of %lx\n"),
10365                               aux.vna_next);
10366                         j = ent.vn_cnt;
10367                         break;
10368                       }
10369                     isum   += aux.vna_next;
10370                     vstart += aux.vna_next;
10371                   }
10372
10373                 if (j < ent.vn_cnt)
10374                   warn (_("Missing Version Needs auxillary information\n"));
10375
10376                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx))
10377                     || (ent.vn_next == 0 && cnt < section->sh_info - 1))
10378                   {
10379                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10380                     cnt = section->sh_info;
10381                     break;
10382                   }
10383                 idx += ent.vn_next;
10384               }
10385
10386             if (cnt < section->sh_info)
10387               warn (_("Missing Version Needs information\n"));
10388
10389             free (eneed);
10390           }
10391           break;
10392
10393         case SHT_GNU_versym:
10394           {
10395             Elf_Internal_Shdr * link_section;
10396             size_t total;
10397             unsigned int cnt;
10398             unsigned char * edata;
10399             unsigned short * data;
10400             char * strtab;
10401             Elf_Internal_Sym * symbols;
10402             Elf_Internal_Shdr * string_sec;
10403             unsigned long num_syms;
10404             long off;
10405
10406             if (section->sh_link >= elf_header.e_shnum)
10407               break;
10408
10409             link_section = section_headers + section->sh_link;
10410             total = section->sh_size / sizeof (Elf_External_Versym);
10411
10412             if (link_section->sh_link >= elf_header.e_shnum)
10413               break;
10414
10415             found = TRUE;
10416
10417             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10418             if (symbols == NULL)
10419               break;
10420
10421             string_sec = section_headers + link_section->sh_link;
10422
10423             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10424                                         string_sec->sh_size,
10425                                         _("version string table"));
10426             if (!strtab)
10427               {
10428                 free (symbols);
10429                 break;
10430               }
10431
10432             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10433                     printable_section_name (section), (unsigned long) total);
10434
10435             printf (_(" Addr: "));
10436             printf_vma (section->sh_addr);
10437             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10438                     (unsigned long) section->sh_offset, section->sh_link,
10439                     printable_section_name (link_section));
10440
10441             off = offset_from_vma (file,
10442                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10443                                    total * sizeof (short));
10444             edata = (unsigned char *) get_data (NULL, file, off, total,
10445                                                 sizeof (short),
10446                                                 _("version symbol data"));
10447             if (!edata)
10448               {
10449                 free (strtab);
10450                 free (symbols);
10451                 break;
10452               }
10453
10454             data = (short unsigned int *) cmalloc (total, sizeof (short));
10455
10456             for (cnt = total; cnt --;)
10457               data[cnt] = byte_get (edata + cnt * sizeof (short),
10458                                     sizeof (short));
10459
10460             free (edata);
10461
10462             for (cnt = 0; cnt < total; cnt += 4)
10463               {
10464                 int j, nn;
10465                 char *name;
10466                 char *invalid = _("*invalid*");
10467
10468                 printf ("  %03x:", cnt);
10469
10470                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10471                   switch (data[cnt + j])
10472                     {
10473                     case 0:
10474                       fputs (_("   0 (*local*)    "), stdout);
10475                       break;
10476
10477                     case 1:
10478                       fputs (_("   1 (*global*)   "), stdout);
10479                       break;
10480
10481                     default:
10482                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10483                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10484
10485                       /* If this index value is greater than the size of the symbols
10486                          array, break to avoid an out-of-bounds read.  */
10487                       if ((unsigned long)(cnt + j) >= num_syms)
10488                         {
10489                           warn (_("invalid index into symbol array\n"));
10490                           break;
10491                         }
10492
10493                       name = NULL;
10494                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10495                         {
10496                           Elf_Internal_Verneed ivn;
10497                           unsigned long offset;
10498
10499                           offset = offset_from_vma
10500                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10501                              sizeof (Elf_External_Verneed));
10502
10503                           do
10504                             {
10505                               Elf_Internal_Vernaux ivna;
10506                               Elf_External_Verneed evn;
10507                               Elf_External_Vernaux evna;
10508                               unsigned long a_off;
10509
10510                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10511                                             _("version need")) == NULL)
10512                                 break;
10513
10514                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10515                               ivn.vn_next = BYTE_GET (evn.vn_next);
10516
10517                               a_off = offset + ivn.vn_aux;
10518
10519                               do
10520                                 {
10521                                   if (get_data (&evna, file, a_off, sizeof (evna),
10522                                                 1, _("version need aux (2)")) == NULL)
10523                                     {
10524                                       ivna.vna_next  = 0;
10525                                       ivna.vna_other = 0;
10526                                     }
10527                                   else
10528                                     {
10529                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10530                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10531                                     }
10532
10533                                   a_off += ivna.vna_next;
10534                                 }
10535                               while (ivna.vna_other != data[cnt + j]
10536                                      && ivna.vna_next != 0);
10537
10538                               if (ivna.vna_other == data[cnt + j])
10539                                 {
10540                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10541
10542                                   if (ivna.vna_name >= string_sec->sh_size)
10543                                     name = invalid;
10544                                   else
10545                                     name = strtab + ivna.vna_name;
10546                                   break;
10547                                 }
10548
10549                               offset += ivn.vn_next;
10550                             }
10551                           while (ivn.vn_next);
10552                         }
10553
10554                       if (data[cnt + j] != 0x8001
10555                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10556                         {
10557                           Elf_Internal_Verdef ivd;
10558                           Elf_External_Verdef evd;
10559                           unsigned long offset;
10560
10561                           offset = offset_from_vma
10562                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10563                              sizeof evd);
10564
10565                           do
10566                             {
10567                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10568                                             _("version def")) == NULL)
10569                                 {
10570                                   ivd.vd_next = 0;
10571                                   /* PR 17531: file: 046-1082287-0.004.  */
10572                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10573                                   break;
10574                                 }
10575                               else
10576                                 {
10577                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10578                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10579                                 }
10580
10581                               offset += ivd.vd_next;
10582                             }
10583                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10584                                  && ivd.vd_next != 0);
10585
10586                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10587                             {
10588                               Elf_External_Verdaux evda;
10589                               Elf_Internal_Verdaux ivda;
10590
10591                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10592
10593                               if (get_data (&evda, file,
10594                                             offset - ivd.vd_next + ivd.vd_aux,
10595                                             sizeof (evda), 1,
10596                                             _("version def aux")) == NULL)
10597                                 break;
10598
10599                               ivda.vda_name = BYTE_GET (evda.vda_name);
10600
10601                               if (ivda.vda_name >= string_sec->sh_size)
10602                                 name = invalid;
10603                               else if (name != NULL && name != invalid)
10604                                 name = _("*both*");
10605                               else
10606                                 name = strtab + ivda.vda_name;
10607                             }
10608                         }
10609                       if (name != NULL)
10610                         nn += printf ("(%s%-*s",
10611                                       name,
10612                                       12 - (int) strlen (name),
10613                                       ")");
10614
10615                       if (nn < 18)
10616                         printf ("%*c", 18 - nn, ' ');
10617                     }
10618
10619                 putchar ('\n');
10620               }
10621
10622             free (data);
10623             free (strtab);
10624             free (symbols);
10625           }
10626           break;
10627
10628         default:
10629           break;
10630         }
10631     }
10632
10633   if (! found)
10634     printf (_("\nNo version information found in this file.\n"));
10635
10636   return TRUE;
10637 }
10638
10639 static const char *
10640 get_symbol_binding (unsigned int binding)
10641 {
10642   static char buff[32];
10643
10644   switch (binding)
10645     {
10646     case STB_LOCAL:     return "LOCAL";
10647     case STB_GLOBAL:    return "GLOBAL";
10648     case STB_WEAK:      return "WEAK";
10649     default:
10650       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10651         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10652                   binding);
10653       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10654         {
10655           if (binding == STB_GNU_UNIQUE
10656               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10657                   /* GNU is still using the default value 0.  */
10658                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10659             return "UNIQUE";
10660           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10661         }
10662       else
10663         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10664       return buff;
10665     }
10666 }
10667
10668 static const char *
10669 get_symbol_type (unsigned int type)
10670 {
10671   static char buff[32];
10672
10673   switch (type)
10674     {
10675     case STT_NOTYPE:    return "NOTYPE";
10676     case STT_OBJECT:    return "OBJECT";
10677     case STT_FUNC:      return "FUNC";
10678     case STT_SECTION:   return "SECTION";
10679     case STT_FILE:      return "FILE";
10680     case STT_COMMON:    return "COMMON";
10681     case STT_TLS:       return "TLS";
10682     case STT_RELC:      return "RELC";
10683     case STT_SRELC:     return "SRELC";
10684     default:
10685       if (type >= STT_LOPROC && type <= STT_HIPROC)
10686         {
10687           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10688             return "THUMB_FUNC";
10689
10690           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10691             return "REGISTER";
10692
10693           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10694             return "PARISC_MILLI";
10695
10696           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10697         }
10698       else if (type >= STT_LOOS && type <= STT_HIOS)
10699         {
10700           if (elf_header.e_machine == EM_PARISC)
10701             {
10702               if (type == STT_HP_OPAQUE)
10703                 return "HP_OPAQUE";
10704               if (type == STT_HP_STUB)
10705                 return "HP_STUB";
10706             }
10707
10708           if (type == STT_GNU_IFUNC
10709               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10710                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10711                   /* GNU is still using the default value 0.  */
10712                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10713             return "IFUNC";
10714
10715           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10716         }
10717       else
10718         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10719       return buff;
10720     }
10721 }
10722
10723 static const char *
10724 get_symbol_visibility (unsigned int visibility)
10725 {
10726   switch (visibility)
10727     {
10728     case STV_DEFAULT:   return "DEFAULT";
10729     case STV_INTERNAL:  return "INTERNAL";
10730     case STV_HIDDEN:    return "HIDDEN";
10731     case STV_PROTECTED: return "PROTECTED";
10732     default:
10733       error (_("Unrecognized visibility value: %u"), visibility);
10734       return _("<unknown>");
10735     }
10736 }
10737
10738 static const char *
10739 get_solaris_symbol_visibility (unsigned int visibility)
10740 {
10741   switch (visibility)
10742     {
10743     case 4: return "EXPORTED";
10744     case 5: return "SINGLETON";
10745     case 6: return "ELIMINATE";
10746     default: return get_symbol_visibility (visibility);
10747     }
10748 }
10749
10750 static const char *
10751 get_mips_symbol_other (unsigned int other)
10752 {
10753   switch (other)
10754     {
10755     case STO_OPTIONAL:      return "OPTIONAL";
10756     case STO_MIPS_PLT:      return "MIPS PLT";
10757     case STO_MIPS_PIC:      return "MIPS PIC";
10758     case STO_MICROMIPS:     return "MICROMIPS";
10759     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10760     case STO_MIPS16:        return "MIPS16";
10761     default:                return NULL;
10762     }
10763 }
10764
10765 static const char *
10766 get_ia64_symbol_other (unsigned int other)
10767 {
10768   if (is_ia64_vms ())
10769     {
10770       static char res[32];
10771
10772       res[0] = 0;
10773
10774       /* Function types is for images and .STB files only.  */
10775       switch (elf_header.e_type)
10776         {
10777         case ET_DYN:
10778         case ET_EXEC:
10779           switch (VMS_ST_FUNC_TYPE (other))
10780             {
10781             case VMS_SFT_CODE_ADDR:
10782               strcat (res, " CA");
10783               break;
10784             case VMS_SFT_SYMV_IDX:
10785               strcat (res, " VEC");
10786               break;
10787             case VMS_SFT_FD:
10788               strcat (res, " FD");
10789               break;
10790             case VMS_SFT_RESERVE:
10791               strcat (res, " RSV");
10792               break;
10793             default:
10794               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10795                     VMS_ST_FUNC_TYPE (other));
10796               strcat (res, " <unknown>");
10797               break;
10798             }
10799           break;
10800         default:
10801           break;
10802         }
10803       switch (VMS_ST_LINKAGE (other))
10804         {
10805         case VMS_STL_IGNORE:
10806           strcat (res, " IGN");
10807           break;
10808         case VMS_STL_RESERVE:
10809           strcat (res, " RSV");
10810           break;
10811         case VMS_STL_STD:
10812           strcat (res, " STD");
10813           break;
10814         case VMS_STL_LNK:
10815           strcat (res, " LNK");
10816           break;
10817         default:
10818           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10819                 VMS_ST_LINKAGE (other));
10820           strcat (res, " <unknown>");
10821           break;
10822         }
10823
10824       if (res[0] != 0)
10825         return res + 1;
10826       else
10827         return res;
10828     }
10829   return NULL;
10830 }
10831
10832 static const char *
10833 get_ppc64_symbol_other (unsigned int other)
10834 {
10835   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10836     {
10837       static char buf[32];
10838       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10839                 PPC64_LOCAL_ENTRY_OFFSET (other));
10840       return buf;
10841     }
10842   return NULL;
10843 }
10844
10845 static const char *
10846 get_symbol_other (unsigned int other)
10847 {
10848   const char * result = NULL;
10849   static char buff [32];
10850
10851   if (other == 0)
10852     return "";
10853
10854   switch (elf_header.e_machine)
10855     {
10856     case EM_MIPS:
10857       result = get_mips_symbol_other (other);
10858       break;
10859     case EM_IA_64:
10860       result = get_ia64_symbol_other (other);
10861       break;
10862     case EM_PPC64:
10863       result = get_ppc64_symbol_other (other);
10864       break;
10865     default:
10866       result = NULL;
10867       break;
10868     }
10869
10870   if (result)
10871     return result;
10872
10873   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10874   return buff;
10875 }
10876
10877 static const char *
10878 get_symbol_index_type (unsigned int type)
10879 {
10880   static char buff[32];
10881
10882   switch (type)
10883     {
10884     case SHN_UNDEF:     return "UND";
10885     case SHN_ABS:       return "ABS";
10886     case SHN_COMMON:    return "COM";
10887     default:
10888       if (type == SHN_IA_64_ANSI_COMMON
10889           && elf_header.e_machine == EM_IA_64
10890           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10891         return "ANSI_COM";
10892       else if ((elf_header.e_machine == EM_X86_64
10893                 || elf_header.e_machine == EM_L1OM
10894                 || elf_header.e_machine == EM_K1OM)
10895                && type == SHN_X86_64_LCOMMON)
10896         return "LARGE_COM";
10897       else if ((type == SHN_MIPS_SCOMMON
10898                 && elf_header.e_machine == EM_MIPS)
10899                || (type == SHN_TIC6X_SCOMMON
10900                    && elf_header.e_machine == EM_TI_C6000))
10901         return "SCOM";
10902       else if (type == SHN_MIPS_SUNDEFINED
10903                && elf_header.e_machine == EM_MIPS)
10904         return "SUND";
10905       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10906         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10907       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10908         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10909       else if (type >= SHN_LORESERVE)
10910         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10911       else if (type >= elf_header.e_shnum)
10912         sprintf (buff, _("bad section index[%3d]"), type);
10913       else
10914         sprintf (buff, "%3d", type);
10915       break;
10916     }
10917
10918   return buff;
10919 }
10920
10921 static bfd_vma *
10922 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10923 {
10924   unsigned char * e_data;
10925   bfd_vma * i_data;
10926
10927   /* If the size_t type is smaller than the bfd_size_type, eg because
10928      you are building a 32-bit tool on a 64-bit host, then make sure
10929      that when (number) is cast to (size_t) no information is lost.  */
10930   if (sizeof (size_t) < sizeof (bfd_size_type)
10931       && (bfd_size_type) ((size_t) number) != number)
10932     {
10933       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10934                " elements of size %u\n"),
10935              number, ent_size);
10936       return NULL;
10937     }
10938
10939   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10940      attempting to allocate memory when the read is bound to fail.  */
10941   if (ent_size * number > current_file_size)
10942     {
10943       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10944              number);
10945       return NULL;
10946     }
10947
10948   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10949   if (e_data == NULL)
10950     {
10951       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10952              number);
10953       return NULL;
10954     }
10955
10956   if (fread (e_data, ent_size, (size_t) number, file) != number)
10957     {
10958       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10959              number * ent_size);
10960       free (e_data);
10961       return NULL;
10962     }
10963
10964   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10965   if (i_data == NULL)
10966     {
10967       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10968                " dynamic entries\n"),
10969              number);
10970       free (e_data);
10971       return NULL;
10972     }
10973
10974   while (number--)
10975     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10976
10977   free (e_data);
10978
10979   return i_data;
10980 }
10981
10982 static void
10983 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10984 {
10985   Elf_Internal_Sym * psym;
10986   int n;
10987
10988   n = print_vma (si, DEC_5);
10989   if (n < 5)
10990     fputs (&"     "[n], stdout);
10991   printf (" %3lu: ", hn);
10992
10993   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10994     {
10995       printf (_("<No info available for dynamic symbol number %lu>\n"),
10996               (unsigned long) si);
10997       return;
10998     }
10999
11000   psym = dynamic_symbols + si;
11001   print_vma (psym->st_value, LONG_HEX);
11002   putchar (' ');
11003   print_vma (psym->st_size, DEC_5);
11004
11005   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11006   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11007
11008   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11009     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11010   else
11011     {
11012       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11013
11014       printf (" %-7s",  get_symbol_visibility (vis));
11015       /* Check to see if any other bits in the st_other field are set.
11016          Note - displaying this information disrupts the layout of the
11017          table being generated, but for the moment this case is very
11018          rare.  */
11019       if (psym->st_other ^ vis)
11020         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11021     }
11022
11023   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11024   if (VALID_DYNAMIC_NAME (psym->st_name))
11025     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11026   else
11027     printf (_(" <corrupt: %14ld>"), psym->st_name);
11028   putchar ('\n');
11029 }
11030
11031 static const char *
11032 get_symbol_version_string (FILE *                       file,
11033                            bfd_boolean                  is_dynsym,
11034                            const char *                 strtab,
11035                            unsigned long int            strtab_size,
11036                            unsigned int                 si,
11037                            Elf_Internal_Sym *           psym,
11038                            enum versioned_symbol_info * sym_info,
11039                            unsigned short *             vna_other)
11040 {
11041   unsigned char data[2];
11042   unsigned short vers_data;
11043   unsigned long offset;
11044
11045   if (!is_dynsym
11046       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11047     return NULL;
11048
11049   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11050                             sizeof data + si * sizeof (vers_data));
11051
11052   if (get_data (&data, file, offset + si * sizeof (vers_data),
11053                 sizeof (data), 1, _("version data")) == NULL)
11054     return NULL;
11055
11056   vers_data = byte_get (data, 2);
11057
11058   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11059     return NULL;
11060
11061   /* Usually we'd only see verdef for defined symbols, and verneed for
11062      undefined symbols.  However, symbols defined by the linker in
11063      .dynbss for variables copied from a shared library in order to
11064      avoid text relocations are defined yet have verneed.  We could
11065      use a heuristic to detect the special case, for example, check
11066      for verneed first on symbols defined in SHT_NOBITS sections, but
11067      it is simpler and more reliable to just look for both verdef and
11068      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11069
11070   if (psym->st_shndx != SHN_UNDEF
11071       && vers_data != 0x8001
11072       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11073     {
11074       Elf_Internal_Verdef ivd;
11075       Elf_Internal_Verdaux ivda;
11076       Elf_External_Verdaux evda;
11077       unsigned long off;
11078
11079       off = offset_from_vma (file,
11080                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11081                              sizeof (Elf_External_Verdef));
11082
11083       do
11084         {
11085           Elf_External_Verdef evd;
11086
11087           if (get_data (&evd, file, off, sizeof (evd), 1,
11088                         _("version def")) == NULL)
11089             {
11090               ivd.vd_ndx = 0;
11091               ivd.vd_aux = 0;
11092               ivd.vd_next = 0;
11093             }
11094           else
11095             {
11096               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11097               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11098               ivd.vd_next = BYTE_GET (evd.vd_next);
11099             }
11100
11101           off += ivd.vd_next;
11102         }
11103       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11104
11105       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11106         {
11107           off -= ivd.vd_next;
11108           off += ivd.vd_aux;
11109
11110           if (get_data (&evda, file, off, sizeof (evda), 1,
11111                         _("version def aux")) != NULL)
11112             {
11113               ivda.vda_name = BYTE_GET (evda.vda_name);
11114
11115               if (psym->st_name != ivda.vda_name)
11116                 {
11117                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11118                                ? symbol_hidden : symbol_public);
11119                   return (ivda.vda_name < strtab_size
11120                           ? strtab + ivda.vda_name : _("<corrupt>"));
11121                 }
11122             }
11123         }
11124     }
11125
11126   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11127     {
11128       Elf_External_Verneed evn;
11129       Elf_Internal_Verneed ivn;
11130       Elf_Internal_Vernaux ivna;
11131
11132       offset = offset_from_vma (file,
11133                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11134                                 sizeof evn);
11135       do
11136         {
11137           unsigned long vna_off;
11138
11139           if (get_data (&evn, file, offset, sizeof (evn), 1,
11140                         _("version need")) == NULL)
11141             {
11142               ivna.vna_next = 0;
11143               ivna.vna_other = 0;
11144               ivna.vna_name = 0;
11145               break;
11146             }
11147
11148           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11149           ivn.vn_next = BYTE_GET (evn.vn_next);
11150
11151           vna_off = offset + ivn.vn_aux;
11152
11153           do
11154             {
11155               Elf_External_Vernaux evna;
11156
11157               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11158                             _("version need aux (3)")) == NULL)
11159                 {
11160                   ivna.vna_next = 0;
11161                   ivna.vna_other = 0;
11162                   ivna.vna_name = 0;
11163                 }
11164               else
11165                 {
11166                   ivna.vna_other = BYTE_GET (evna.vna_other);
11167                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11168                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11169                 }
11170
11171               vna_off += ivna.vna_next;
11172             }
11173           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11174
11175           if (ivna.vna_other == vers_data)
11176             break;
11177
11178           offset += ivn.vn_next;
11179         }
11180       while (ivn.vn_next != 0);
11181
11182       if (ivna.vna_other == vers_data)
11183         {
11184           *sym_info = symbol_undefined;
11185           *vna_other = ivna.vna_other;
11186           return (ivna.vna_name < strtab_size
11187                   ? strtab + ivna.vna_name : _("<corrupt>"));
11188         }
11189     }
11190   return NULL;
11191 }
11192
11193 /* Dump the symbol table.  */
11194 static bfd_boolean
11195 process_symbol_table (FILE * file)
11196 {
11197   Elf_Internal_Shdr * section;
11198   bfd_size_type nbuckets = 0;
11199   bfd_size_type nchains = 0;
11200   bfd_vma * buckets = NULL;
11201   bfd_vma * chains = NULL;
11202   bfd_vma ngnubuckets = 0;
11203   bfd_vma * gnubuckets = NULL;
11204   bfd_vma * gnuchains = NULL;
11205   bfd_vma gnusymidx = 0;
11206   bfd_size_type ngnuchains = 0;
11207
11208   if (!do_syms && !do_dyn_syms && !do_histogram)
11209     return TRUE;
11210
11211   if (dynamic_info[DT_HASH]
11212       && (do_histogram
11213           || (do_using_dynamic
11214               && !do_dyn_syms
11215               && dynamic_strings != NULL)))
11216     {
11217       unsigned char nb[8];
11218       unsigned char nc[8];
11219       unsigned int hash_ent_size = 4;
11220
11221       if ((elf_header.e_machine == EM_ALPHA
11222            || elf_header.e_machine == EM_S390
11223            || elf_header.e_machine == EM_S390_OLD)
11224           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11225         hash_ent_size = 8;
11226
11227       if (fseek (file,
11228                  (archive_file_offset
11229                   + offset_from_vma (file, dynamic_info[DT_HASH],
11230                                      sizeof nb + sizeof nc)),
11231                  SEEK_SET))
11232         {
11233           error (_("Unable to seek to start of dynamic information\n"));
11234           goto no_hash;
11235         }
11236
11237       if (fread (nb, hash_ent_size, 1, file) != 1)
11238         {
11239           error (_("Failed to read in number of buckets\n"));
11240           goto no_hash;
11241         }
11242
11243       if (fread (nc, hash_ent_size, 1, file) != 1)
11244         {
11245           error (_("Failed to read in number of chains\n"));
11246           goto no_hash;
11247         }
11248
11249       nbuckets = byte_get (nb, hash_ent_size);
11250       nchains  = byte_get (nc, hash_ent_size);
11251
11252       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11253       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11254
11255     no_hash:
11256       if (buckets == NULL || chains == NULL)
11257         {
11258           if (do_using_dynamic)
11259             return FALSE;
11260           free (buckets);
11261           free (chains);
11262           buckets = NULL;
11263           chains = NULL;
11264           nbuckets = 0;
11265           nchains = 0;
11266         }
11267     }
11268
11269   if (dynamic_info_DT_GNU_HASH
11270       && (do_histogram
11271           || (do_using_dynamic
11272               && !do_dyn_syms
11273               && dynamic_strings != NULL)))
11274     {
11275       unsigned char nb[16];
11276       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11277       bfd_vma buckets_vma;
11278
11279       if (fseek (file,
11280                  (archive_file_offset
11281                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11282                                      sizeof nb)),
11283                  SEEK_SET))
11284         {
11285           error (_("Unable to seek to start of dynamic information\n"));
11286           goto no_gnu_hash;
11287         }
11288
11289       if (fread (nb, 16, 1, file) != 1)
11290         {
11291           error (_("Failed to read in number of buckets\n"));
11292           goto no_gnu_hash;
11293         }
11294
11295       ngnubuckets = byte_get (nb, 4);
11296       gnusymidx = byte_get (nb + 4, 4);
11297       bitmaskwords = byte_get (nb + 8, 4);
11298       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11299       if (is_32bit_elf)
11300         buckets_vma += bitmaskwords * 4;
11301       else
11302         buckets_vma += bitmaskwords * 8;
11303
11304       if (fseek (file,
11305                  (archive_file_offset
11306                   + offset_from_vma (file, buckets_vma, 4)),
11307                  SEEK_SET))
11308         {
11309           error (_("Unable to seek to start of dynamic information\n"));
11310           goto no_gnu_hash;
11311         }
11312
11313       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11314
11315       if (gnubuckets == NULL)
11316         goto no_gnu_hash;
11317
11318       for (i = 0; i < ngnubuckets; i++)
11319         if (gnubuckets[i] != 0)
11320           {
11321             if (gnubuckets[i] < gnusymidx)
11322               return FALSE;
11323
11324             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11325               maxchain = gnubuckets[i];
11326           }
11327
11328       if (maxchain == 0xffffffff)
11329         goto no_gnu_hash;
11330
11331       maxchain -= gnusymidx;
11332
11333       if (fseek (file,
11334                  (archive_file_offset
11335                   + offset_from_vma (file, buckets_vma
11336                                            + 4 * (ngnubuckets + maxchain), 4)),
11337                  SEEK_SET))
11338         {
11339           error (_("Unable to seek to start of dynamic information\n"));
11340           goto no_gnu_hash;
11341         }
11342
11343       do
11344         {
11345           if (fread (nb, 4, 1, file) != 1)
11346             {
11347               error (_("Failed to determine last chain length\n"));
11348               goto no_gnu_hash;
11349             }
11350
11351           if (maxchain + 1 == 0)
11352             goto no_gnu_hash;
11353
11354           ++maxchain;
11355         }
11356       while ((byte_get (nb, 4) & 1) == 0);
11357
11358       if (fseek (file,
11359                  (archive_file_offset
11360                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11361                  SEEK_SET))
11362         {
11363           error (_("Unable to seek to start of dynamic information\n"));
11364           goto no_gnu_hash;
11365         }
11366
11367       gnuchains = get_dynamic_data (file, maxchain, 4);
11368       ngnuchains = maxchain;
11369
11370     no_gnu_hash:
11371       if (gnuchains == NULL)
11372         {
11373           free (gnubuckets);
11374           gnubuckets = NULL;
11375           ngnubuckets = 0;
11376           if (do_using_dynamic)
11377             return FALSE;
11378         }
11379     }
11380
11381   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11382       && do_syms
11383       && do_using_dynamic
11384       && dynamic_strings != NULL
11385       && dynamic_symbols != NULL)
11386     {
11387       unsigned long hn;
11388
11389       if (dynamic_info[DT_HASH])
11390         {
11391           bfd_vma si;
11392
11393           printf (_("\nSymbol table for image:\n"));
11394           if (is_32bit_elf)
11395             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11396           else
11397             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11398
11399           for (hn = 0; hn < nbuckets; hn++)
11400             {
11401               if (! buckets[hn])
11402                 continue;
11403
11404               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11405                 print_dynamic_symbol (si, hn);
11406             }
11407         }
11408
11409       if (dynamic_info_DT_GNU_HASH)
11410         {
11411           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11412           if (is_32bit_elf)
11413             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11414           else
11415             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11416
11417           for (hn = 0; hn < ngnubuckets; ++hn)
11418             if (gnubuckets[hn] != 0)
11419               {
11420                 bfd_vma si = gnubuckets[hn];
11421                 bfd_vma off = si - gnusymidx;
11422
11423                 do
11424                   {
11425                     print_dynamic_symbol (si, hn);
11426                     si++;
11427                   }
11428                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11429               }
11430         }
11431     }
11432   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11433            && section_headers != NULL)
11434     {
11435       unsigned int i;
11436
11437       for (i = 0, section = section_headers;
11438            i < elf_header.e_shnum;
11439            i++, section++)
11440         {
11441           unsigned int si;
11442           char * strtab = NULL;
11443           unsigned long int strtab_size = 0;
11444           Elf_Internal_Sym * symtab;
11445           Elf_Internal_Sym * psym;
11446           unsigned long num_syms;
11447
11448           if ((section->sh_type != SHT_SYMTAB
11449                && section->sh_type != SHT_DYNSYM)
11450               || (!do_syms
11451                   && section->sh_type == SHT_SYMTAB))
11452             continue;
11453
11454           if (section->sh_entsize == 0)
11455             {
11456               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11457                       printable_section_name (section));
11458               continue;
11459             }
11460
11461           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11462                   printable_section_name (section),
11463                   (unsigned long) (section->sh_size / section->sh_entsize));
11464
11465           if (is_32bit_elf)
11466             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11467           else
11468             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11469
11470           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11471           if (symtab == NULL)
11472             continue;
11473
11474           if (section->sh_link == elf_header.e_shstrndx)
11475             {
11476               strtab = string_table;
11477               strtab_size = string_table_length;
11478             }
11479           else if (section->sh_link < elf_header.e_shnum)
11480             {
11481               Elf_Internal_Shdr * string_sec;
11482
11483               string_sec = section_headers + section->sh_link;
11484
11485               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11486                                           1, string_sec->sh_size,
11487                                           _("string table"));
11488               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11489             }
11490
11491           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11492             {
11493               const char *version_string;
11494               enum versioned_symbol_info sym_info;
11495               unsigned short vna_other;
11496
11497               printf ("%6d: ", si);
11498               print_vma (psym->st_value, LONG_HEX);
11499               putchar (' ');
11500               print_vma (psym->st_size, DEC_5);
11501               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11502               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11503               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11504                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11505               else
11506                 {
11507                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11508
11509                   printf (" %-7s", get_symbol_visibility (vis));
11510                   /* Check to see if any other bits in the st_other field are set.
11511                      Note - displaying this information disrupts the layout of the
11512                      table being generated, but for the moment this case is very rare.  */
11513                   if (psym->st_other ^ vis)
11514                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11515                 }
11516               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11517               print_symbol (25, psym->st_name < strtab_size
11518                             ? strtab + psym->st_name : _("<corrupt>"));
11519
11520               version_string
11521                 = get_symbol_version_string (file,
11522                                              section->sh_type == SHT_DYNSYM,
11523                                              strtab, strtab_size, si,
11524                                              psym, &sym_info, &vna_other);
11525               if (version_string)
11526                 {
11527                   if (sym_info == symbol_undefined)
11528                     printf ("@%s (%d)", version_string, vna_other);
11529                   else
11530                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11531                             version_string);
11532                 }
11533
11534               putchar ('\n');
11535
11536               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11537                   && si >= section->sh_info
11538                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11539                   && elf_header.e_machine != EM_MIPS
11540                   /* Solaris binaries have been found to violate this requirement as
11541                      well.  Not sure if this is a bug or an ABI requirement.  */
11542                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11543                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11544                       si, printable_section_name (section), section->sh_info);
11545             }
11546
11547           free (symtab);
11548           if (strtab != string_table)
11549             free (strtab);
11550         }
11551     }
11552   else if (do_syms)
11553     printf
11554       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11555
11556   if (do_histogram && buckets != NULL)
11557     {
11558       unsigned long * lengths;
11559       unsigned long * counts;
11560       unsigned long hn;
11561       bfd_vma si;
11562       unsigned long maxlength = 0;
11563       unsigned long nzero_counts = 0;
11564       unsigned long nsyms = 0;
11565       unsigned long chained;
11566
11567       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11568               (unsigned long) nbuckets);
11569
11570       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11571       if (lengths == NULL)
11572         {
11573           error (_("Out of memory allocating space for histogram buckets\n"));
11574           return FALSE;
11575         }
11576
11577       printf (_(" Length  Number     %% of total  Coverage\n"));
11578       for (hn = 0; hn < nbuckets; ++hn)
11579         {
11580           for (si = buckets[hn], chained = 0;
11581                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11582                si = chains[si], ++chained)
11583             {
11584               ++nsyms;
11585               if (maxlength < ++lengths[hn])
11586                 ++maxlength;
11587             }
11588
11589             /* PR binutils/17531: A corrupt binary could contain broken
11590                histogram data.  Do not go into an infinite loop trying
11591                to process it.  */
11592             if (chained > nchains)
11593               {
11594                 error (_("histogram chain is corrupt\n"));
11595                 break;
11596               }
11597         }
11598
11599       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11600       if (counts == NULL)
11601         {
11602           free (lengths);
11603           error (_("Out of memory allocating space for histogram counts\n"));
11604           return FALSE;
11605         }
11606
11607       for (hn = 0; hn < nbuckets; ++hn)
11608         ++counts[lengths[hn]];
11609
11610       if (nbuckets > 0)
11611         {
11612           unsigned long i;
11613           printf ("      0  %-10lu (%5.1f%%)\n",
11614                   counts[0], (counts[0] * 100.0) / nbuckets);
11615           for (i = 1; i <= maxlength; ++i)
11616             {
11617               nzero_counts += counts[i] * i;
11618               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11619                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11620                       (nzero_counts * 100.0) / nsyms);
11621             }
11622         }
11623
11624       free (counts);
11625       free (lengths);
11626     }
11627
11628   if (buckets != NULL)
11629     {
11630       free (buckets);
11631       free (chains);
11632     }
11633
11634   if (do_histogram && gnubuckets != NULL)
11635     {
11636       unsigned long * lengths;
11637       unsigned long * counts;
11638       unsigned long hn;
11639       unsigned long maxlength = 0;
11640       unsigned long nzero_counts = 0;
11641       unsigned long nsyms = 0;
11642
11643       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11644               (unsigned long) ngnubuckets);
11645
11646       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11647       if (lengths == NULL)
11648         {
11649           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11650           return FALSE;
11651         }
11652
11653       printf (_(" Length  Number     %% of total  Coverage\n"));
11654
11655       for (hn = 0; hn < ngnubuckets; ++hn)
11656         if (gnubuckets[hn] != 0)
11657           {
11658             bfd_vma off, length = 1;
11659
11660             for (off = gnubuckets[hn] - gnusymidx;
11661                  /* PR 17531 file: 010-77222-0.004.  */
11662                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11663                  ++off)
11664               ++length;
11665             lengths[hn] = length;
11666             if (length > maxlength)
11667               maxlength = length;
11668             nsyms += length;
11669           }
11670
11671       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11672       if (counts == NULL)
11673         {
11674           free (lengths);
11675           error (_("Out of memory allocating space for gnu histogram counts\n"));
11676           return FALSE;
11677         }
11678
11679       for (hn = 0; hn < ngnubuckets; ++hn)
11680         ++counts[lengths[hn]];
11681
11682       if (ngnubuckets > 0)
11683         {
11684           unsigned long j;
11685           printf ("      0  %-10lu (%5.1f%%)\n",
11686                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11687           for (j = 1; j <= maxlength; ++j)
11688             {
11689               nzero_counts += counts[j] * j;
11690               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11691                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11692                       (nzero_counts * 100.0) / nsyms);
11693             }
11694         }
11695
11696       free (counts);
11697       free (lengths);
11698       free (gnubuckets);
11699       free (gnuchains);
11700     }
11701
11702   return TRUE;
11703 }
11704
11705 static bfd_boolean
11706 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11707 {
11708   unsigned int i;
11709
11710   if (dynamic_syminfo == NULL
11711       || !do_dynamic)
11712     /* No syminfo, this is ok.  */
11713     return TRUE;
11714
11715   /* There better should be a dynamic symbol section.  */
11716   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11717     return FALSE;
11718
11719   if (dynamic_addr)
11720     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11721             dynamic_syminfo_offset, dynamic_syminfo_nent);
11722
11723   printf (_(" Num: Name                           BoundTo     Flags\n"));
11724   for (i = 0; i < dynamic_syminfo_nent; ++i)
11725     {
11726       unsigned short int flags = dynamic_syminfo[i].si_flags;
11727
11728       printf ("%4d: ", i);
11729       if (i >= num_dynamic_syms)
11730         printf (_("<corrupt index>"));
11731       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11732         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11733       else
11734         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11735       putchar (' ');
11736
11737       switch (dynamic_syminfo[i].si_boundto)
11738         {
11739         case SYMINFO_BT_SELF:
11740           fputs ("SELF       ", stdout);
11741           break;
11742         case SYMINFO_BT_PARENT:
11743           fputs ("PARENT     ", stdout);
11744           break;
11745         default:
11746           if (dynamic_syminfo[i].si_boundto > 0
11747               && dynamic_syminfo[i].si_boundto < dynamic_nent
11748               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11749             {
11750               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11751               putchar (' ' );
11752             }
11753           else
11754             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11755           break;
11756         }
11757
11758       if (flags & SYMINFO_FLG_DIRECT)
11759         printf (" DIRECT");
11760       if (flags & SYMINFO_FLG_PASSTHRU)
11761         printf (" PASSTHRU");
11762       if (flags & SYMINFO_FLG_COPY)
11763         printf (" COPY");
11764       if (flags & SYMINFO_FLG_LAZYLOAD)
11765         printf (" LAZYLOAD");
11766
11767       puts ("");
11768     }
11769
11770   return TRUE;
11771 }
11772
11773 #define IN_RANGE(START,END,ADDR,OFF)            \
11774   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11775
11776 /* Check to see if the given reloc needs to be handled in a target specific
11777    manner.  If so then process the reloc and return TRUE otherwise return
11778    FALSE.
11779
11780    If called with reloc == NULL, then this is a signal that reloc processing
11781    for the current section has finished, and any saved state should be
11782    discarded.  */
11783
11784 static bfd_boolean
11785 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11786                                 unsigned char *     start,
11787                                 unsigned char *     end,
11788                                 Elf_Internal_Sym *  symtab,
11789                                 unsigned long       num_syms)
11790 {
11791   unsigned int reloc_type = 0;
11792   unsigned long sym_index = 0;
11793
11794   if (reloc)
11795     {
11796       reloc_type = get_reloc_type (reloc->r_info);
11797       sym_index = get_reloc_symindex (reloc->r_info);
11798     }
11799
11800   switch (elf_header.e_machine)
11801     {
11802     case EM_MSP430:
11803     case EM_MSP430_OLD:
11804       {
11805         static Elf_Internal_Sym * saved_sym = NULL;
11806
11807         if (reloc == NULL)
11808           {
11809             saved_sym = NULL;
11810             return TRUE;
11811           }
11812
11813         switch (reloc_type)
11814           {
11815           case 10: /* R_MSP430_SYM_DIFF */
11816             if (uses_msp430x_relocs ())
11817               break;
11818             /* Fall through.  */
11819           case 21: /* R_MSP430X_SYM_DIFF */
11820             /* PR 21139.  */
11821             if (sym_index >= num_syms)
11822               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11823                      sym_index);
11824             else
11825               saved_sym = symtab + sym_index;
11826             return TRUE;
11827
11828           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11829           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11830             goto handle_sym_diff;
11831
11832           case 5: /* R_MSP430_16_BYTE */
11833           case 9: /* R_MSP430_8 */
11834             if (uses_msp430x_relocs ())
11835               break;
11836             goto handle_sym_diff;
11837
11838           case 2: /* R_MSP430_ABS16 */
11839           case 15: /* R_MSP430X_ABS16 */
11840             if (! uses_msp430x_relocs ())
11841               break;
11842             goto handle_sym_diff;
11843
11844           handle_sym_diff:
11845             if (saved_sym != NULL)
11846               {
11847                 int reloc_size = reloc_type == 1 ? 4 : 2;
11848                 bfd_vma value;
11849
11850                 if (sym_index >= num_syms)
11851                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11852                          sym_index);
11853                 else
11854                   {
11855                     value = reloc->r_addend + (symtab[sym_index].st_value
11856                                                - saved_sym->st_value);
11857
11858                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11859                       byte_put (start + reloc->r_offset, value, reloc_size);
11860                     else
11861                       /* PR 21137 */
11862                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11863                              (long) reloc->r_offset);
11864                   }
11865
11866                 saved_sym = NULL;
11867                 return TRUE;
11868               }
11869             break;
11870
11871           default:
11872             if (saved_sym != NULL)
11873               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11874             break;
11875           }
11876         break;
11877       }
11878
11879     case EM_MN10300:
11880     case EM_CYGNUS_MN10300:
11881       {
11882         static Elf_Internal_Sym * saved_sym = NULL;
11883
11884         if (reloc == NULL)
11885           {
11886             saved_sym = NULL;
11887             return TRUE;
11888           }
11889
11890         switch (reloc_type)
11891           {
11892           case 34: /* R_MN10300_ALIGN */
11893             return TRUE;
11894           case 33: /* R_MN10300_SYM_DIFF */
11895             if (sym_index >= num_syms)
11896               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11897                      sym_index);
11898             else
11899               saved_sym = symtab + sym_index;
11900             return TRUE;
11901
11902           case 1: /* R_MN10300_32 */
11903           case 2: /* R_MN10300_16 */
11904             if (saved_sym != NULL)
11905               {
11906                 int reloc_size = reloc_type == 1 ? 4 : 2;
11907                 bfd_vma value;
11908
11909                 if (sym_index >= num_syms)
11910                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11911                          sym_index);
11912                 else
11913                   {
11914                     value = reloc->r_addend + (symtab[sym_index].st_value
11915                                                - saved_sym->st_value);
11916
11917                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11918                       byte_put (start + reloc->r_offset, value, reloc_size);
11919                     else
11920                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11921                              (long) reloc->r_offset);
11922                   }
11923
11924                 saved_sym = NULL;
11925                 return TRUE;
11926               }
11927             break;
11928           default:
11929             if (saved_sym != NULL)
11930               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11931             break;
11932           }
11933         break;
11934       }
11935
11936     case EM_RL78:
11937       {
11938         static bfd_vma saved_sym1 = 0;
11939         static bfd_vma saved_sym2 = 0;
11940         static bfd_vma value;
11941
11942         if (reloc == NULL)
11943           {
11944             saved_sym1 = saved_sym2 = 0;
11945             return TRUE;
11946           }
11947
11948         switch (reloc_type)
11949           {
11950           case 0x80: /* R_RL78_SYM.  */
11951             saved_sym1 = saved_sym2;
11952             if (sym_index >= num_syms)
11953               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11954                      sym_index);
11955             else
11956               {
11957                 saved_sym2 = symtab[sym_index].st_value;
11958                 saved_sym2 += reloc->r_addend;
11959               }
11960             return TRUE;
11961
11962           case 0x83: /* R_RL78_OPsub.  */
11963             value = saved_sym1 - saved_sym2;
11964             saved_sym2 = saved_sym1 = 0;
11965             return TRUE;
11966             break;
11967
11968           case 0x41: /* R_RL78_ABS32.  */
11969             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11970               byte_put (start + reloc->r_offset, value, 4);
11971             else
11972               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11973                      (long) reloc->r_offset);
11974             value = 0;
11975             return TRUE;
11976
11977           case 0x43: /* R_RL78_ABS16.  */
11978             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11979               byte_put (start + reloc->r_offset, value, 2);
11980             else
11981               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11982                      (long) reloc->r_offset);
11983             value = 0;
11984             return TRUE;
11985
11986           default:
11987             break;
11988           }
11989         break;
11990       }
11991     }
11992
11993   return FALSE;
11994 }
11995
11996 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11997    DWARF debug sections.  This is a target specific test.  Note - we do not
11998    go through the whole including-target-headers-multiple-times route, (as
11999    we have already done with <elf/h8.h>) because this would become very
12000    messy and even then this function would have to contain target specific
12001    information (the names of the relocs instead of their numeric values).
12002    FIXME: This is not the correct way to solve this problem.  The proper way
12003    is to have target specific reloc sizing and typing functions created by
12004    the reloc-macros.h header, in the same way that it already creates the
12005    reloc naming functions.  */
12006
12007 static bfd_boolean
12008 is_32bit_abs_reloc (unsigned int reloc_type)
12009 {
12010   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12011   switch (elf_header.e_machine)
12012     {
12013     case EM_386:
12014     case EM_IAMCU:
12015       return reloc_type == 1; /* R_386_32.  */
12016     case EM_68K:
12017       return reloc_type == 1; /* R_68K_32.  */
12018     case EM_860:
12019       return reloc_type == 1; /* R_860_32.  */
12020     case EM_960:
12021       return reloc_type == 2; /* R_960_32.  */
12022     case EM_AARCH64:
12023       return (reloc_type == 258
12024               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12025     case EM_ADAPTEVA_EPIPHANY:
12026       return reloc_type == 3;
12027     case EM_ALPHA:
12028       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12029     case EM_ARC:
12030       return reloc_type == 1; /* R_ARC_32.  */
12031     case EM_ARC_COMPACT:
12032     case EM_ARC_COMPACT2:
12033       return reloc_type == 4; /* R_ARC_32.  */
12034     case EM_ARM:
12035       return reloc_type == 2; /* R_ARM_ABS32 */
12036     case EM_AVR_OLD:
12037     case EM_AVR:
12038       return reloc_type == 1;
12039     case EM_BLACKFIN:
12040       return reloc_type == 0x12; /* R_byte4_data.  */
12041     case EM_CRIS:
12042       return reloc_type == 3; /* R_CRIS_32.  */
12043     case EM_CR16:
12044       return reloc_type == 3; /* R_CR16_NUM32.  */
12045     case EM_CRX:
12046       return reloc_type == 15; /* R_CRX_NUM32.  */
12047     case EM_CYGNUS_FRV:
12048       return reloc_type == 1;
12049     case EM_CYGNUS_D10V:
12050     case EM_D10V:
12051       return reloc_type == 6; /* R_D10V_32.  */
12052     case EM_CYGNUS_D30V:
12053     case EM_D30V:
12054       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12055     case EM_DLX:
12056       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12057     case EM_CYGNUS_FR30:
12058     case EM_FR30:
12059       return reloc_type == 3; /* R_FR30_32.  */
12060     case EM_FT32:
12061       return reloc_type == 1; /* R_FT32_32.  */
12062     case EM_H8S:
12063     case EM_H8_300:
12064     case EM_H8_300H:
12065       return reloc_type == 1; /* R_H8_DIR32.  */
12066     case EM_IA_64:
12067       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12068               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12069               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12070               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12071     case EM_IP2K_OLD:
12072     case EM_IP2K:
12073       return reloc_type == 2; /* R_IP2K_32.  */
12074     case EM_IQ2000:
12075       return reloc_type == 2; /* R_IQ2000_32.  */
12076     case EM_LATTICEMICO32:
12077       return reloc_type == 3; /* R_LM32_32.  */
12078     case EM_M32C_OLD:
12079     case EM_M32C:
12080       return reloc_type == 3; /* R_M32C_32.  */
12081     case EM_M32R:
12082       return reloc_type == 34; /* R_M32R_32_RELA.  */
12083     case EM_68HC11:
12084     case EM_68HC12:
12085       return reloc_type == 6; /* R_M68HC11_32.  */
12086     case EM_MCORE:
12087       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12088     case EM_CYGNUS_MEP:
12089       return reloc_type == 4; /* R_MEP_32.  */
12090     case EM_METAG:
12091       return reloc_type == 2; /* R_METAG_ADDR32.  */
12092     case EM_MICROBLAZE:
12093       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12094     case EM_MIPS:
12095       return reloc_type == 2; /* R_MIPS_32.  */
12096     case EM_MMIX:
12097       return reloc_type == 4; /* R_MMIX_32.  */
12098     case EM_CYGNUS_MN10200:
12099     case EM_MN10200:
12100       return reloc_type == 1; /* R_MN10200_32.  */
12101     case EM_CYGNUS_MN10300:
12102     case EM_MN10300:
12103       return reloc_type == 1; /* R_MN10300_32.  */
12104     case EM_MOXIE:
12105       return reloc_type == 1; /* R_MOXIE_32.  */
12106     case EM_MSP430_OLD:
12107     case EM_MSP430:
12108       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12109     case EM_MT:
12110       return reloc_type == 2; /* R_MT_32.  */
12111     case EM_NDS32:
12112       return reloc_type == 20; /* R_NDS32_RELA.  */
12113     case EM_ALTERA_NIOS2:
12114       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12115     case EM_NIOS32:
12116       return reloc_type == 1; /* R_NIOS_32.  */
12117     case EM_OR1K:
12118       return reloc_type == 1; /* R_OR1K_32.  */
12119     case EM_PARISC:
12120       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12121               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12122     case EM_PJ:
12123     case EM_PJ_OLD:
12124       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12125     case EM_PPC64:
12126       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12127     case EM_PPC:
12128       return reloc_type == 1; /* R_PPC_ADDR32.  */
12129     case EM_TI_PRU:
12130       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12131     case EM_RISCV:
12132       return reloc_type == 1; /* R_RISCV_32.  */
12133     case EM_RL78:
12134       return reloc_type == 1; /* R_RL78_DIR32.  */
12135     case EM_RX:
12136       return reloc_type == 1; /* R_RX_DIR32.  */
12137     case EM_S370:
12138       return reloc_type == 1; /* R_I370_ADDR31.  */
12139     case EM_S390_OLD:
12140     case EM_S390:
12141       return reloc_type == 4; /* R_S390_32.  */
12142     case EM_SCORE:
12143       return reloc_type == 8; /* R_SCORE_ABS32.  */
12144     case EM_SH:
12145       return reloc_type == 1; /* R_SH_DIR32.  */
12146     case EM_SPARC32PLUS:
12147     case EM_SPARCV9:
12148     case EM_SPARC:
12149       return reloc_type == 3 /* R_SPARC_32.  */
12150         || reloc_type == 23; /* R_SPARC_UA32.  */
12151     case EM_SPU:
12152       return reloc_type == 6; /* R_SPU_ADDR32 */
12153     case EM_TI_C6000:
12154       return reloc_type == 1; /* R_C6000_ABS32.  */
12155     case EM_TILEGX:
12156       return reloc_type == 2; /* R_TILEGX_32.  */
12157     case EM_TILEPRO:
12158       return reloc_type == 1; /* R_TILEPRO_32.  */
12159     case EM_CYGNUS_V850:
12160     case EM_V850:
12161       return reloc_type == 6; /* R_V850_ABS32.  */
12162     case EM_V800:
12163       return reloc_type == 0x33; /* R_V810_WORD.  */
12164     case EM_VAX:
12165       return reloc_type == 1; /* R_VAX_32.  */
12166     case EM_VISIUM:
12167       return reloc_type == 3;  /* R_VISIUM_32. */
12168     case EM_WEBASSEMBLY:
12169       return reloc_type == 1;  /* R_WASM32_32.  */
12170     case EM_X86_64:
12171     case EM_L1OM:
12172     case EM_K1OM:
12173       return reloc_type == 10; /* R_X86_64_32.  */
12174     case EM_XC16X:
12175     case EM_C166:
12176       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12177     case EM_XGATE:
12178       return reloc_type == 4; /* R_XGATE_32.  */
12179     case EM_XSTORMY16:
12180       return reloc_type == 1; /* R_XSTROMY16_32.  */
12181     case EM_XTENSA_OLD:
12182     case EM_XTENSA:
12183       return reloc_type == 1; /* R_XTENSA_32.  */
12184     default:
12185       {
12186         static unsigned int prev_warn = 0;
12187
12188         /* Avoid repeating the same warning multiple times.  */
12189         if (prev_warn != elf_header.e_machine)
12190           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12191                  elf_header.e_machine);
12192         prev_warn = elf_header.e_machine;
12193         return FALSE;
12194       }
12195     }
12196 }
12197
12198 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12199    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12200
12201 static bfd_boolean
12202 is_32bit_pcrel_reloc (unsigned int reloc_type)
12203 {
12204   switch (elf_header.e_machine)
12205   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12206     {
12207     case EM_386:
12208     case EM_IAMCU:
12209       return reloc_type == 2;  /* R_386_PC32.  */
12210     case EM_68K:
12211       return reloc_type == 4;  /* R_68K_PC32.  */
12212     case EM_AARCH64:
12213       return reloc_type == 261; /* R_AARCH64_PREL32 */
12214     case EM_ADAPTEVA_EPIPHANY:
12215       return reloc_type == 6;
12216     case EM_ALPHA:
12217       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12218     case EM_ARC_COMPACT:
12219     case EM_ARC_COMPACT2:
12220       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12221     case EM_ARM:
12222       return reloc_type == 3;  /* R_ARM_REL32 */
12223     case EM_AVR_OLD:
12224     case EM_AVR:
12225       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12226     case EM_MICROBLAZE:
12227       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12228     case EM_OR1K:
12229       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12230     case EM_PARISC:
12231       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12232     case EM_PPC:
12233       return reloc_type == 26; /* R_PPC_REL32.  */
12234     case EM_PPC64:
12235       return reloc_type == 26; /* R_PPC64_REL32.  */
12236     case EM_S390_OLD:
12237     case EM_S390:
12238       return reloc_type == 5;  /* R_390_PC32.  */
12239     case EM_SH:
12240       return reloc_type == 2;  /* R_SH_REL32.  */
12241     case EM_SPARC32PLUS:
12242     case EM_SPARCV9:
12243     case EM_SPARC:
12244       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12245     case EM_SPU:
12246       return reloc_type == 13; /* R_SPU_REL32.  */
12247     case EM_TILEGX:
12248       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12249     case EM_TILEPRO:
12250       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12251     case EM_VISIUM:
12252       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12253     case EM_X86_64:
12254     case EM_L1OM:
12255     case EM_K1OM:
12256       return reloc_type == 2;  /* R_X86_64_PC32.  */
12257     case EM_XTENSA_OLD:
12258     case EM_XTENSA:
12259       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12260     default:
12261       /* Do not abort or issue an error message here.  Not all targets use
12262          pc-relative 32-bit relocs in their DWARF debug information and we
12263          have already tested for target coverage in is_32bit_abs_reloc.  A
12264          more helpful warning message will be generated by apply_relocations
12265          anyway, so just return.  */
12266       return FALSE;
12267     }
12268 }
12269
12270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12271    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12272
12273 static bfd_boolean
12274 is_64bit_abs_reloc (unsigned int reloc_type)
12275 {
12276   switch (elf_header.e_machine)
12277     {
12278     case EM_AARCH64:
12279       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12280     case EM_ALPHA:
12281       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12282     case EM_IA_64:
12283       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12284               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12285     case EM_PARISC:
12286       return reloc_type == 80; /* R_PARISC_DIR64.  */
12287     case EM_PPC64:
12288       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12289     case EM_RISCV:
12290       return reloc_type == 2; /* R_RISCV_64.  */
12291     case EM_SPARC32PLUS:
12292     case EM_SPARCV9:
12293     case EM_SPARC:
12294       return reloc_type == 32 /* R_SPARC_64.  */
12295         || reloc_type == 54; /* R_SPARC_UA64.  */
12296     case EM_X86_64:
12297     case EM_L1OM:
12298     case EM_K1OM:
12299       return reloc_type == 1; /* R_X86_64_64.  */
12300     case EM_S390_OLD:
12301     case EM_S390:
12302       return reloc_type == 22;  /* R_S390_64.  */
12303     case EM_TILEGX:
12304       return reloc_type == 1; /* R_TILEGX_64.  */
12305     case EM_MIPS:
12306       return reloc_type == 18;  /* R_MIPS_64.  */
12307     default:
12308       return FALSE;
12309     }
12310 }
12311
12312 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12313    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12314
12315 static bfd_boolean
12316 is_64bit_pcrel_reloc (unsigned int reloc_type)
12317 {
12318   switch (elf_header.e_machine)
12319     {
12320     case EM_AARCH64:
12321       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12322     case EM_ALPHA:
12323       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12324     case EM_IA_64:
12325       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12326               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12327     case EM_PARISC:
12328       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12329     case EM_PPC64:
12330       return reloc_type == 44; /* R_PPC64_REL64.  */
12331     case EM_SPARC32PLUS:
12332     case EM_SPARCV9:
12333     case EM_SPARC:
12334       return reloc_type == 46; /* R_SPARC_DISP64.  */
12335     case EM_X86_64:
12336     case EM_L1OM:
12337     case EM_K1OM:
12338       return reloc_type == 24; /* R_X86_64_PC64.  */
12339     case EM_S390_OLD:
12340     case EM_S390:
12341       return reloc_type == 23;  /* R_S390_PC64.  */
12342     case EM_TILEGX:
12343       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12344     default:
12345       return FALSE;
12346     }
12347 }
12348
12349 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12350    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12351
12352 static bfd_boolean
12353 is_24bit_abs_reloc (unsigned int reloc_type)
12354 {
12355   switch (elf_header.e_machine)
12356     {
12357     case EM_CYGNUS_MN10200:
12358     case EM_MN10200:
12359       return reloc_type == 4; /* R_MN10200_24.  */
12360     case EM_FT32:
12361       return reloc_type == 5; /* R_FT32_20.  */
12362     default:
12363       return FALSE;
12364     }
12365 }
12366
12367 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12368    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12369
12370 static bfd_boolean
12371 is_16bit_abs_reloc (unsigned int reloc_type)
12372 {
12373   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12374   switch (elf_header.e_machine)
12375     {
12376     case EM_ARC:
12377     case EM_ARC_COMPACT:
12378     case EM_ARC_COMPACT2:
12379       return reloc_type == 2; /* R_ARC_16.  */
12380     case EM_ADAPTEVA_EPIPHANY:
12381       return reloc_type == 5;
12382     case EM_AVR_OLD:
12383     case EM_AVR:
12384       return reloc_type == 4; /* R_AVR_16.  */
12385     case EM_CYGNUS_D10V:
12386     case EM_D10V:
12387       return reloc_type == 3; /* R_D10V_16.  */
12388     case EM_H8S:
12389     case EM_H8_300:
12390     case EM_H8_300H:
12391       return reloc_type == R_H8_DIR16;
12392     case EM_IP2K_OLD:
12393     case EM_IP2K:
12394       return reloc_type == 1; /* R_IP2K_16.  */
12395     case EM_M32C_OLD:
12396     case EM_M32C:
12397       return reloc_type == 1; /* R_M32C_16 */
12398     case EM_CYGNUS_MN10200:
12399     case EM_MN10200:
12400       return reloc_type == 2; /* R_MN10200_16.  */
12401     case EM_CYGNUS_MN10300:
12402     case EM_MN10300:
12403       return reloc_type == 2; /* R_MN10300_16.  */
12404     case EM_MSP430:
12405       if (uses_msp430x_relocs ())
12406         return reloc_type == 2; /* R_MSP430_ABS16.  */
12407       /* Fall through.  */
12408     case EM_MSP430_OLD:
12409       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12410     case EM_NDS32:
12411       return reloc_type == 19; /* R_NDS32_RELA.  */
12412     case EM_ALTERA_NIOS2:
12413       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12414     case EM_NIOS32:
12415       return reloc_type == 9; /* R_NIOS_16.  */
12416     case EM_OR1K:
12417       return reloc_type == 2; /* R_OR1K_16.  */
12418     case EM_TI_PRU:
12419       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12420     case EM_TI_C6000:
12421       return reloc_type == 2; /* R_C6000_ABS16.  */
12422     case EM_VISIUM:
12423       return reloc_type == 2; /* R_VISIUM_16. */
12424     case EM_XC16X:
12425     case EM_C166:
12426       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12427     case EM_XGATE:
12428       return reloc_type == 3; /* R_XGATE_16.  */
12429     default:
12430       return FALSE;
12431     }
12432 }
12433
12434 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12435    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12436
12437 static bfd_boolean
12438 is_none_reloc (unsigned int reloc_type)
12439 {
12440   switch (elf_header.e_machine)
12441     {
12442     case EM_386:     /* R_386_NONE.  */
12443     case EM_68K:     /* R_68K_NONE.  */
12444     case EM_ADAPTEVA_EPIPHANY:
12445     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12446     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12447     case EM_ARC:     /* R_ARC_NONE.  */
12448     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12449     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12450     case EM_ARM:     /* R_ARM_NONE.  */
12451     case EM_C166:    /* R_XC16X_NONE.  */
12452     case EM_CRIS:    /* R_CRIS_NONE.  */
12453     case EM_FT32:    /* R_FT32_NONE.  */
12454     case EM_IA_64:   /* R_IA64_NONE.  */
12455     case EM_K1OM:    /* R_X86_64_NONE.  */
12456     case EM_L1OM:    /* R_X86_64_NONE.  */
12457     case EM_M32R:    /* R_M32R_NONE.  */
12458     case EM_MIPS:    /* R_MIPS_NONE.  */
12459     case EM_MN10300: /* R_MN10300_NONE.  */
12460     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12461     case EM_NIOS32:  /* R_NIOS_NONE.  */
12462     case EM_OR1K:    /* R_OR1K_NONE. */
12463     case EM_PARISC:  /* R_PARISC_NONE.  */
12464     case EM_PPC64:   /* R_PPC64_NONE.  */
12465     case EM_PPC:     /* R_PPC_NONE.  */
12466     case EM_RISCV:   /* R_RISCV_NONE.  */
12467     case EM_S390:    /* R_390_NONE.  */
12468     case EM_S390_OLD:
12469     case EM_SH:      /* R_SH_NONE.  */
12470     case EM_SPARC32PLUS:
12471     case EM_SPARC:   /* R_SPARC_NONE.  */
12472     case EM_SPARCV9:
12473     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12474     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12475     case EM_TI_C6000:/* R_C6000_NONE.  */
12476     case EM_X86_64:  /* R_X86_64_NONE.  */
12477     case EM_XC16X:
12478     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12479       return reloc_type == 0;
12480
12481     case EM_AARCH64:
12482       return reloc_type == 0 || reloc_type == 256;
12483     case EM_AVR_OLD:
12484     case EM_AVR:
12485       return (reloc_type == 0 /* R_AVR_NONE.  */
12486               || reloc_type == 30 /* R_AVR_DIFF8.  */
12487               || reloc_type == 31 /* R_AVR_DIFF16.  */
12488               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12489     case EM_METAG:
12490       return reloc_type == 3; /* R_METAG_NONE.  */
12491     case EM_NDS32:
12492       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12493               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12494               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12495               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12496               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12497     case EM_TI_PRU:
12498       return (reloc_type == 0       /* R_PRU_NONE.  */
12499               || reloc_type == 65   /* R_PRU_DIFF8.  */
12500               || reloc_type == 66   /* R_PRU_DIFF16.  */
12501               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12502     case EM_XTENSA_OLD:
12503     case EM_XTENSA:
12504       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12505               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12506               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12507               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12508     }
12509   return FALSE;
12510 }
12511
12512 /* Returns TRUE if there is a relocation against
12513    section NAME at OFFSET bytes.  */
12514
12515 bfd_boolean
12516 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12517 {
12518   Elf_Internal_Rela * relocs;
12519   Elf_Internal_Rela * rp;
12520
12521   if (dsec == NULL || dsec->reloc_info == NULL)
12522     return FALSE;
12523
12524   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12525
12526   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12527     if (rp->r_offset == offset)
12528       return TRUE;
12529
12530    return FALSE;
12531 }
12532
12533 /* Apply relocations to a section.
12534    Returns TRUE upon success, FALSE otherwise.
12535    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12536    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12537    will be set to the number of relocs loaded.
12538
12539    Note: So far support has been added only for those relocations
12540    which can be found in debug sections. FIXME: Add support for
12541    more relocations ?  */
12542
12543 static bfd_boolean
12544 apply_relocations (void *                     file,
12545                    const Elf_Internal_Shdr *  section,
12546                    unsigned char *            start,
12547                    bfd_size_type              size,
12548                    void **                    relocs_return,
12549                    unsigned long *            num_relocs_return)
12550 {
12551   Elf_Internal_Shdr * relsec;
12552   unsigned char * end = start + size;
12553   bfd_boolean res = TRUE;
12554
12555   if (relocs_return != NULL)
12556     {
12557       * (Elf_Internal_Rela **) relocs_return = NULL;
12558       * num_relocs_return = 0;
12559     }
12560
12561   if (elf_header.e_type != ET_REL)
12562     /* No relocs to apply.  */
12563     return TRUE;
12564
12565   /* Find the reloc section associated with the section.  */
12566   for (relsec = section_headers;
12567        relsec < section_headers + elf_header.e_shnum;
12568        ++relsec)
12569     {
12570       bfd_boolean is_rela;
12571       unsigned long num_relocs;
12572       Elf_Internal_Rela * relocs;
12573       Elf_Internal_Rela * rp;
12574       Elf_Internal_Shdr * symsec;
12575       Elf_Internal_Sym * symtab;
12576       unsigned long num_syms;
12577       Elf_Internal_Sym * sym;
12578
12579       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12580           || relsec->sh_info >= elf_header.e_shnum
12581           || section_headers + relsec->sh_info != section
12582           || relsec->sh_size == 0
12583           || relsec->sh_link >= elf_header.e_shnum)
12584         continue;
12585
12586       is_rela = relsec->sh_type == SHT_RELA;
12587
12588       if (is_rela)
12589         {
12590           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12591                                   relsec->sh_size, & relocs, & num_relocs))
12592             return FALSE;
12593         }
12594       else
12595         {
12596           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12597                                  relsec->sh_size, & relocs, & num_relocs))
12598             return FALSE;
12599         }
12600
12601       /* SH uses RELA but uses in place value instead of the addend field.  */
12602       if (elf_header.e_machine == EM_SH)
12603         is_rela = FALSE;
12604
12605       symsec = section_headers + relsec->sh_link;
12606       if (symsec->sh_type != SHT_SYMTAB
12607           && symsec->sh_type != SHT_DYNSYM)
12608         return FALSE;
12609       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12610
12611       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12612         {
12613           bfd_vma         addend;
12614           unsigned int    reloc_type;
12615           unsigned int    reloc_size;
12616           unsigned char * rloc;
12617           unsigned long   sym_index;
12618
12619           reloc_type = get_reloc_type (rp->r_info);
12620
12621           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12622             continue;
12623           else if (is_none_reloc (reloc_type))
12624             continue;
12625           else if (is_32bit_abs_reloc (reloc_type)
12626                    || is_32bit_pcrel_reloc (reloc_type))
12627             reloc_size = 4;
12628           else if (is_64bit_abs_reloc (reloc_type)
12629                    || is_64bit_pcrel_reloc (reloc_type))
12630             reloc_size = 8;
12631           else if (is_24bit_abs_reloc (reloc_type))
12632             reloc_size = 3;
12633           else if (is_16bit_abs_reloc (reloc_type))
12634             reloc_size = 2;
12635           else
12636             {
12637               static unsigned int prev_reloc = 0;
12638               if (reloc_type != prev_reloc)
12639                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12640                       reloc_type, printable_section_name (section));
12641               prev_reloc = reloc_type;
12642               res = FALSE;
12643               continue;
12644             }
12645
12646           rloc = start + rp->r_offset;
12647           if ((rloc + reloc_size) > end || (rloc < start))
12648             {
12649               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12650                     (unsigned long) rp->r_offset,
12651                     printable_section_name (section));
12652               res = FALSE;
12653               continue;
12654             }
12655
12656           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12657           if (sym_index >= num_syms)
12658             {
12659               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12660                     sym_index, printable_section_name (section));
12661               res = FALSE;
12662               continue;
12663             }
12664           sym = symtab + sym_index;
12665
12666           /* If the reloc has a symbol associated with it,
12667              make sure that it is of an appropriate type.
12668
12669              Relocations against symbols without type can happen.
12670              Gcc -feliminate-dwarf2-dups may generate symbols
12671              without type for debug info.
12672
12673              Icc generates relocations against function symbols
12674              instead of local labels.
12675
12676              Relocations against object symbols can happen, eg when
12677              referencing a global array.  For an example of this see
12678              the _clz.o binary in libgcc.a.  */
12679           if (sym != symtab
12680               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12681               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12682             {
12683               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12684                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12685                     (long int)(rp - relocs),
12686                     printable_section_name (relsec));
12687               res = FALSE;
12688               continue;
12689             }
12690
12691           addend = 0;
12692           if (is_rela)
12693             addend += rp->r_addend;
12694           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12695              partial_inplace.  */
12696           if (!is_rela
12697               || (elf_header.e_machine == EM_XTENSA
12698                   && reloc_type == 1)
12699               || ((elf_header.e_machine == EM_PJ
12700                    || elf_header.e_machine == EM_PJ_OLD)
12701                   && reloc_type == 1)
12702               || ((elf_header.e_machine == EM_D30V
12703                    || elf_header.e_machine == EM_CYGNUS_D30V)
12704                   && reloc_type == 12))
12705             addend += byte_get (rloc, reloc_size);
12706
12707           if (is_32bit_pcrel_reloc (reloc_type)
12708               || is_64bit_pcrel_reloc (reloc_type))
12709             {
12710               /* On HPPA, all pc-relative relocations are biased by 8.  */
12711               if (elf_header.e_machine == EM_PARISC)
12712                 addend -= 8;
12713               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12714                         reloc_size);
12715             }
12716           else
12717             byte_put (rloc, addend + sym->st_value, reloc_size);
12718         }
12719
12720       free (symtab);
12721       /* Let the target specific reloc processing code know that
12722          we have finished with these relocs.  */
12723       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12724
12725       if (relocs_return)
12726         {
12727           * (Elf_Internal_Rela **) relocs_return = relocs;
12728           * num_relocs_return = num_relocs;
12729         }
12730       else
12731         free (relocs);
12732
12733       break;
12734     }
12735
12736   return res;
12737 }
12738
12739 #ifdef SUPPORT_DISASSEMBLY
12740 static bfd_boolean
12741 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12742 {
12743   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12744
12745   /* FIXME: XXX -- to be done --- XXX */
12746
12747   return TRUE;
12748 }
12749 #endif
12750
12751 /* Reads in the contents of SECTION from FILE, returning a pointer
12752    to a malloc'ed buffer or NULL if something went wrong.  */
12753
12754 static char *
12755 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12756 {
12757   bfd_size_type num_bytes;
12758
12759   num_bytes = section->sh_size;
12760
12761   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12762     {
12763       printf (_("Section '%s' has no data to dump.\n"),
12764               printable_section_name (section));
12765       return NULL;
12766     }
12767
12768   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12769                              _("section contents"));
12770 }
12771
12772 /* Uncompresses a section that was compressed using zlib, in place.  */
12773
12774 static bfd_boolean
12775 uncompress_section_contents (unsigned char **buffer,
12776                              dwarf_size_type uncompressed_size,
12777                              dwarf_size_type *size)
12778 {
12779   dwarf_size_type compressed_size = *size;
12780   unsigned char * compressed_buffer = *buffer;
12781   unsigned char * uncompressed_buffer;
12782   z_stream strm;
12783   int rc;
12784
12785   /* It is possible the section consists of several compressed
12786      buffers concatenated together, so we uncompress in a loop.  */
12787   /* PR 18313: The state field in the z_stream structure is supposed
12788      to be invisible to the user (ie us), but some compilers will
12789      still complain about it being used without initialisation.  So
12790      we first zero the entire z_stream structure and then set the fields
12791      that we need.  */
12792   memset (& strm, 0, sizeof strm);
12793   strm.avail_in = compressed_size;
12794   strm.next_in = (Bytef *) compressed_buffer;
12795   strm.avail_out = uncompressed_size;
12796   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12797
12798   rc = inflateInit (& strm);
12799   while (strm.avail_in > 0)
12800     {
12801       if (rc != Z_OK)
12802         goto fail;
12803       strm.next_out = ((Bytef *) uncompressed_buffer
12804                        + (uncompressed_size - strm.avail_out));
12805       rc = inflate (&strm, Z_FINISH);
12806       if (rc != Z_STREAM_END)
12807         goto fail;
12808       rc = inflateReset (& strm);
12809     }
12810   rc = inflateEnd (& strm);
12811   if (rc != Z_OK
12812       || strm.avail_out != 0)
12813     goto fail;
12814
12815   *buffer = uncompressed_buffer;
12816   *size = uncompressed_size;
12817   return TRUE;
12818
12819  fail:
12820   free (uncompressed_buffer);
12821   /* Indicate decompression failure.  */
12822   *buffer = NULL;
12823   return FALSE;
12824 }
12825
12826 static bfd_boolean
12827 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12828 {
12829   Elf_Internal_Shdr *  relsec;
12830   bfd_size_type        num_bytes;
12831   unsigned char *      data;
12832   unsigned char *      end;
12833   unsigned char *      real_start;
12834   unsigned char *      start;
12835   bfd_boolean          some_strings_shown;
12836
12837   real_start = start = (unsigned char *) get_section_contents (section, file);
12838   if (start == NULL)
12839     /* PR 21820: Do not fail if the section was empty.  */
12840     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12841
12842   num_bytes = section->sh_size;
12843
12844   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12845
12846   if (decompress_dumps)
12847     {
12848       dwarf_size_type new_size = num_bytes;
12849       dwarf_size_type uncompressed_size = 0;
12850
12851       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12852         {
12853           Elf_Internal_Chdr chdr;
12854           unsigned int compression_header_size
12855             = get_compression_header (& chdr, (unsigned char *) start,
12856                                       num_bytes);
12857
12858           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12859             {
12860               warn (_("section '%s' has unsupported compress type: %d\n"),
12861                     printable_section_name (section), chdr.ch_type);
12862               return FALSE;
12863             }
12864           else if (chdr.ch_addralign != section->sh_addralign)
12865             {
12866               warn (_("compressed section '%s' is corrupted\n"),
12867                     printable_section_name (section));
12868               return FALSE;
12869             }
12870           uncompressed_size = chdr.ch_size;
12871           start += compression_header_size;
12872           new_size -= compression_header_size;
12873         }
12874       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12875         {
12876           /* Read the zlib header.  In this case, it should be "ZLIB"
12877              followed by the uncompressed section size, 8 bytes in
12878              big-endian order.  */
12879           uncompressed_size = start[4]; uncompressed_size <<= 8;
12880           uncompressed_size += start[5]; uncompressed_size <<= 8;
12881           uncompressed_size += start[6]; uncompressed_size <<= 8;
12882           uncompressed_size += start[7]; uncompressed_size <<= 8;
12883           uncompressed_size += start[8]; uncompressed_size <<= 8;
12884           uncompressed_size += start[9]; uncompressed_size <<= 8;
12885           uncompressed_size += start[10]; uncompressed_size <<= 8;
12886           uncompressed_size += start[11];
12887           start += 12;
12888           new_size -= 12;
12889         }
12890
12891       if (uncompressed_size)
12892         {
12893           if (uncompress_section_contents (& start,
12894                                            uncompressed_size, & new_size))
12895             num_bytes = new_size;
12896           else
12897             {
12898               error (_("Unable to decompress section %s\n"),
12899                      printable_section_name (section));
12900               return FALSE;
12901             }
12902         }
12903       else
12904         start = real_start;
12905     }
12906
12907   /* If the section being dumped has relocations against it the user might
12908      be expecting these relocations to have been applied.  Check for this
12909      case and issue a warning message in order to avoid confusion.
12910      FIXME: Maybe we ought to have an option that dumps a section with
12911      relocs applied ?  */
12912   for (relsec = section_headers;
12913        relsec < section_headers + elf_header.e_shnum;
12914        ++relsec)
12915     {
12916       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12917           || relsec->sh_info >= elf_header.e_shnum
12918           || section_headers + relsec->sh_info != section
12919           || relsec->sh_size == 0
12920           || relsec->sh_link >= elf_header.e_shnum)
12921         continue;
12922
12923       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12924       break;
12925     }
12926
12927   data = start;
12928   end  = start + num_bytes;
12929   some_strings_shown = FALSE;
12930
12931   while (data < end)
12932     {
12933       while (!ISPRINT (* data))
12934         if (++ data >= end)
12935           break;
12936
12937       if (data < end)
12938         {
12939           size_t maxlen = end - data;
12940
12941 #ifndef __MSVCRT__
12942           /* PR 11128: Use two separate invocations in order to work
12943              around bugs in the Solaris 8 implementation of printf.  */
12944           printf ("  [%6tx]  ", data - start);
12945 #else
12946           printf ("  [%6Ix]  ", (size_t) (data - start));
12947 #endif
12948           if (maxlen > 0)
12949             {
12950               print_symbol ((int) maxlen, (const char *) data);
12951               putchar ('\n');
12952               data += strnlen ((const char *) data, maxlen);
12953             }
12954           else
12955             {
12956               printf (_("<corrupt>\n"));
12957               data = end;
12958             }
12959           some_strings_shown = TRUE;
12960         }
12961     }
12962
12963   if (! some_strings_shown)
12964     printf (_("  No strings found in this section."));
12965
12966   free (real_start);
12967
12968   putchar ('\n');
12969   return TRUE;
12970 }
12971
12972 static bfd_boolean
12973 dump_section_as_bytes (Elf_Internal_Shdr * section,
12974                        FILE * file,
12975                        bfd_boolean relocate)
12976 {
12977   Elf_Internal_Shdr * relsec;
12978   bfd_size_type       bytes;
12979   bfd_size_type       section_size;
12980   bfd_vma             addr;
12981   unsigned char *     data;
12982   unsigned char *     real_start;
12983   unsigned char *     start;
12984
12985   real_start = start = (unsigned char *) get_section_contents (section, file);
12986   if (start == NULL)
12987     /* PR 21820: Do not fail if the section was empty.  */
12988     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12989
12990   section_size = section->sh_size;
12991
12992   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12993
12994   if (decompress_dumps)
12995     {
12996       dwarf_size_type new_size = section_size;
12997       dwarf_size_type uncompressed_size = 0;
12998
12999       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13000         {
13001           Elf_Internal_Chdr chdr;
13002           unsigned int compression_header_size
13003             = get_compression_header (& chdr, start, section_size);
13004
13005           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13006             {
13007               warn (_("section '%s' has unsupported compress type: %d\n"),
13008                     printable_section_name (section), chdr.ch_type);
13009               return FALSE;
13010             }
13011           else if (chdr.ch_addralign != section->sh_addralign)
13012             {
13013               warn (_("compressed section '%s' is corrupted\n"),
13014                     printable_section_name (section));
13015               return FALSE;
13016             }
13017           uncompressed_size = chdr.ch_size;
13018           start += compression_header_size;
13019           new_size -= compression_header_size;
13020         }
13021       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13022         {
13023           /* Read the zlib header.  In this case, it should be "ZLIB"
13024              followed by the uncompressed section size, 8 bytes in
13025              big-endian order.  */
13026           uncompressed_size = start[4]; uncompressed_size <<= 8;
13027           uncompressed_size += start[5]; uncompressed_size <<= 8;
13028           uncompressed_size += start[6]; uncompressed_size <<= 8;
13029           uncompressed_size += start[7]; uncompressed_size <<= 8;
13030           uncompressed_size += start[8]; uncompressed_size <<= 8;
13031           uncompressed_size += start[9]; uncompressed_size <<= 8;
13032           uncompressed_size += start[10]; uncompressed_size <<= 8;
13033           uncompressed_size += start[11];
13034           start += 12;
13035           new_size -= 12;
13036         }
13037
13038       if (uncompressed_size)
13039         {
13040           if (uncompress_section_contents (& start, uncompressed_size,
13041                                            & new_size))
13042             {
13043               section_size = new_size;
13044             }
13045           else
13046             {
13047               error (_("Unable to decompress section %s\n"),
13048                      printable_section_name (section));
13049               /* FIXME: Print the section anyway ?  */
13050               return FALSE;
13051             }
13052         }
13053       else
13054         start = real_start;
13055     }
13056
13057   if (relocate)
13058     {
13059       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13060         return FALSE;
13061     }
13062   else
13063     {
13064       /* If the section being dumped has relocations against it the user might
13065          be expecting these relocations to have been applied.  Check for this
13066          case and issue a warning message in order to avoid confusion.
13067          FIXME: Maybe we ought to have an option that dumps a section with
13068          relocs applied ?  */
13069       for (relsec = section_headers;
13070            relsec < section_headers + elf_header.e_shnum;
13071            ++relsec)
13072         {
13073           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13074               || relsec->sh_info >= elf_header.e_shnum
13075               || section_headers + relsec->sh_info != section
13076               || relsec->sh_size == 0
13077               || relsec->sh_link >= elf_header.e_shnum)
13078             continue;
13079
13080           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13081           break;
13082         }
13083     }
13084
13085   addr = section->sh_addr;
13086   bytes = section_size;
13087   data = start;
13088
13089   while (bytes)
13090     {
13091       int j;
13092       int k;
13093       int lbytes;
13094
13095       lbytes = (bytes > 16 ? 16 : bytes);
13096
13097       printf ("  0x%8.8lx ", (unsigned long) addr);
13098
13099       for (j = 0; j < 16; j++)
13100         {
13101           if (j < lbytes)
13102             printf ("%2.2x", data[j]);
13103           else
13104             printf ("  ");
13105
13106           if ((j & 3) == 3)
13107             printf (" ");
13108         }
13109
13110       for (j = 0; j < lbytes; j++)
13111         {
13112           k = data[j];
13113           if (k >= ' ' && k < 0x7f)
13114             printf ("%c", k);
13115           else
13116             printf (".");
13117         }
13118
13119       putchar ('\n');
13120
13121       data  += lbytes;
13122       addr  += lbytes;
13123       bytes -= lbytes;
13124     }
13125
13126   free (real_start);
13127
13128   putchar ('\n');
13129   return TRUE;
13130 }
13131
13132 static bfd_boolean
13133 load_specific_debug_section (enum dwarf_section_display_enum debug,
13134                              const Elf_Internal_Shdr * sec, void * file)
13135 {
13136   struct dwarf_section * section = &debug_displays [debug].section;
13137   char buf [64];
13138
13139   /* If it is already loaded, do nothing.  */
13140   if (section->start != NULL)
13141     return TRUE;
13142
13143   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13144   section->address = sec->sh_addr;
13145   section->user_data = NULL;
13146   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13147                                                sec->sh_offset, 1,
13148                                                sec->sh_size, buf);
13149   if (section->start == NULL)
13150     section->size = 0;
13151   else
13152     {
13153       unsigned char *start = section->start;
13154       dwarf_size_type size = sec->sh_size;
13155       dwarf_size_type uncompressed_size = 0;
13156
13157       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13158         {
13159           Elf_Internal_Chdr chdr;
13160           unsigned int compression_header_size;
13161
13162           if (size < (is_32bit_elf
13163                       ? sizeof (Elf32_External_Chdr)
13164                       : sizeof (Elf64_External_Chdr)))
13165             {
13166               warn (_("compressed section %s is too small to contain a compression header"),
13167                     section->name);
13168               return FALSE;
13169             }
13170
13171           compression_header_size = get_compression_header (&chdr, start, size);
13172
13173           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13174             {
13175               warn (_("section '%s' has unsupported compress type: %d\n"),
13176                     section->name, chdr.ch_type);
13177               return FALSE;
13178             }
13179           else if (chdr.ch_addralign != sec->sh_addralign)
13180             {
13181               warn (_("compressed section '%s' is corrupted\n"),
13182                     section->name);
13183               return FALSE;
13184             }
13185           uncompressed_size = chdr.ch_size;
13186           start += compression_header_size;
13187           size -= compression_header_size;
13188         }
13189       else if (size > 12 && streq ((char *) start, "ZLIB"))
13190         {
13191           /* Read the zlib header.  In this case, it should be "ZLIB"
13192              followed by the uncompressed section size, 8 bytes in
13193              big-endian order.  */
13194           uncompressed_size = start[4]; uncompressed_size <<= 8;
13195           uncompressed_size += start[5]; uncompressed_size <<= 8;
13196           uncompressed_size += start[6]; uncompressed_size <<= 8;
13197           uncompressed_size += start[7]; uncompressed_size <<= 8;
13198           uncompressed_size += start[8]; uncompressed_size <<= 8;
13199           uncompressed_size += start[9]; uncompressed_size <<= 8;
13200           uncompressed_size += start[10]; uncompressed_size <<= 8;
13201           uncompressed_size += start[11];
13202           start += 12;
13203           size -= 12;
13204         }
13205
13206       if (uncompressed_size)
13207         {
13208           if (uncompress_section_contents (&start, uncompressed_size,
13209                                            &size))
13210             {
13211               /* Free the compressed buffer, update the section buffer
13212                  and the section size if uncompress is successful.  */
13213               free (section->start);
13214               section->start = start;
13215             }
13216           else
13217             {
13218               error (_("Unable to decompress section %s\n"),
13219                      printable_section_name (sec));
13220               return FALSE;
13221             }
13222         }
13223
13224       section->size = size;
13225     }
13226
13227   if (section->start == NULL)
13228     return FALSE;
13229
13230   if (debug_displays [debug].relocate)
13231     {
13232       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13233                                & section->reloc_info, & section->num_relocs))
13234         return FALSE;
13235     }
13236   else
13237     {
13238       section->reloc_info = NULL;
13239       section->num_relocs = 0;
13240     }
13241
13242   return TRUE;
13243 }
13244
13245 /* If this is not NULL, load_debug_section will only look for sections
13246    within the list of sections given here.  */
13247 static unsigned int * section_subset = NULL;
13248
13249 bfd_boolean
13250 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13251 {
13252   struct dwarf_section * section = &debug_displays [debug].section;
13253   Elf_Internal_Shdr * sec;
13254
13255   /* Locate the debug section.  */
13256   sec = find_section_in_set (section->uncompressed_name, section_subset);
13257   if (sec != NULL)
13258     section->name = section->uncompressed_name;
13259   else
13260     {
13261       sec = find_section_in_set (section->compressed_name, section_subset);
13262       if (sec != NULL)
13263         section->name = section->compressed_name;
13264     }
13265   if (sec == NULL)
13266     return FALSE;
13267
13268   /* If we're loading from a subset of sections, and we've loaded
13269      a section matching this name before, it's likely that it's a
13270      different one.  */
13271   if (section_subset != NULL)
13272     free_debug_section (debug);
13273
13274   return load_specific_debug_section (debug, sec, (FILE *) file);
13275 }
13276
13277 void
13278 free_debug_section (enum dwarf_section_display_enum debug)
13279 {
13280   struct dwarf_section * section = &debug_displays [debug].section;
13281
13282   if (section->start == NULL)
13283     return;
13284
13285   free ((char *) section->start);
13286   section->start = NULL;
13287   section->address = 0;
13288   section->size = 0;
13289 }
13290
13291 static bfd_boolean
13292 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13293 {
13294   char * name = SECTION_NAME (section);
13295   const char * print_name = printable_section_name (section);
13296   bfd_size_type length;
13297   bfd_boolean result = TRUE;
13298   int i;
13299
13300   length = section->sh_size;
13301   if (length == 0)
13302     {
13303       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13304       return TRUE;
13305     }
13306   if (section->sh_type == SHT_NOBITS)
13307     {
13308       /* There is no point in dumping the contents of a debugging section
13309          which has the NOBITS type - the bits in the file will be random.
13310          This can happen when a file containing a .eh_frame section is
13311          stripped with the --only-keep-debug command line option.  */
13312       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13313               print_name);
13314       return FALSE;
13315     }
13316
13317   if (const_strneq (name, ".gnu.linkonce.wi."))
13318     name = ".debug_info";
13319
13320   /* See if we know how to display the contents of this section.  */
13321   for (i = 0; i < max; i++)
13322     if (streq (debug_displays[i].section.uncompressed_name, name)
13323         || (i == line && const_strneq (name, ".debug_line."))
13324         || streq (debug_displays[i].section.compressed_name, name))
13325       {
13326         struct dwarf_section * sec = &debug_displays [i].section;
13327         int secondary = (section != find_section (name));
13328
13329         if (secondary)
13330           free_debug_section ((enum dwarf_section_display_enum) i);
13331
13332         if (i == line && const_strneq (name, ".debug_line."))
13333           sec->name = name;
13334         else if (streq (sec->uncompressed_name, name))
13335           sec->name = sec->uncompressed_name;
13336         else
13337           sec->name = sec->compressed_name;
13338         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13339                                          section, file))
13340           {
13341             /* If this debug section is part of a CU/TU set in a .dwp file,
13342                restrict load_debug_section to the sections in that set.  */
13343             section_subset = find_cu_tu_set (file, shndx);
13344
13345             result &= debug_displays[i].display (sec, file);
13346
13347             section_subset = NULL;
13348
13349             if (secondary || (i != info && i != abbrev))
13350               free_debug_section ((enum dwarf_section_display_enum) i);
13351           }
13352
13353         break;
13354       }
13355
13356   if (i == max)
13357     {
13358       printf (_("Unrecognized debug section: %s\n"), print_name);
13359       result = FALSE;
13360     }
13361
13362   return result;
13363 }
13364
13365 /* Set DUMP_SECTS for all sections where dumps were requested
13366    based on section name.  */
13367
13368 static void
13369 initialise_dumps_byname (void)
13370 {
13371   struct dump_list_entry * cur;
13372
13373   for (cur = dump_sects_byname; cur; cur = cur->next)
13374     {
13375       unsigned int i;
13376       bfd_boolean any = FALSE;
13377
13378       for (i = 0; i < elf_header.e_shnum; i++)
13379         if (streq (SECTION_NAME (section_headers + i), cur->name))
13380           {
13381             request_dump_bynumber (i, cur->type);
13382             any = TRUE;
13383           }
13384
13385       if (!any)
13386         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13387               cur->name);
13388     }
13389 }
13390
13391 static bfd_boolean
13392 process_section_contents (FILE * file)
13393 {
13394   Elf_Internal_Shdr * section;
13395   unsigned int i;
13396   bfd_boolean res = TRUE;
13397
13398   if (! do_dump)
13399     return TRUE;
13400
13401   initialise_dumps_byname ();
13402
13403   for (i = 0, section = section_headers;
13404        i < elf_header.e_shnum && i < num_dump_sects;
13405        i++, section++)
13406     {
13407 #ifdef SUPPORT_DISASSEMBLY
13408       if (dump_sects[i] & DISASS_DUMP)
13409         disassemble_section (section, file);
13410 #endif
13411       if (dump_sects[i] & HEX_DUMP)
13412         {
13413           if (! dump_section_as_bytes (section, file, FALSE))
13414             res = FALSE;
13415         }
13416
13417       if (dump_sects[i] & RELOC_DUMP)
13418         {
13419           if (! dump_section_as_bytes (section, file, TRUE))
13420             res = FALSE;
13421         }
13422
13423       if (dump_sects[i] & STRING_DUMP)
13424         {
13425           if (! dump_section_as_strings (section, file))
13426             res = FALSE;
13427         }
13428
13429       if (dump_sects[i] & DEBUG_DUMP)
13430         {
13431           if (! display_debug_section (i, section, file))
13432             res = FALSE;
13433         }
13434     }
13435
13436   /* Check to see if the user requested a
13437      dump of a section that does not exist.  */
13438   while (i < num_dump_sects)
13439     {
13440       if (dump_sects[i])
13441         {
13442           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13443           res = FALSE;
13444         }
13445       i++;
13446     }
13447
13448   return res;
13449 }
13450
13451 static void
13452 process_mips_fpe_exception (int mask)
13453 {
13454   if (mask)
13455     {
13456       bfd_boolean first = TRUE;
13457
13458       if (mask & OEX_FPU_INEX)
13459         fputs ("INEX", stdout), first = FALSE;
13460       if (mask & OEX_FPU_UFLO)
13461         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13462       if (mask & OEX_FPU_OFLO)
13463         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13464       if (mask & OEX_FPU_DIV0)
13465         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13466       if (mask & OEX_FPU_INVAL)
13467         printf ("%sINVAL", first ? "" : "|");
13468     }
13469   else
13470     fputs ("0", stdout);
13471 }
13472
13473 /* Display's the value of TAG at location P.  If TAG is
13474    greater than 0 it is assumed to be an unknown tag, and
13475    a message is printed to this effect.  Otherwise it is
13476    assumed that a message has already been printed.
13477
13478    If the bottom bit of TAG is set it assumed to have a
13479    string value, otherwise it is assumed to have an integer
13480    value.
13481
13482    Returns an updated P pointing to the first unread byte
13483    beyond the end of TAG's value.
13484
13485    Reads at or beyond END will not be made.  */
13486
13487 static unsigned char *
13488 display_tag_value (signed int tag,
13489                    unsigned char * p,
13490                    const unsigned char * const end)
13491 {
13492   unsigned long val;
13493
13494   if (tag > 0)
13495     printf ("  Tag_unknown_%d: ", tag);
13496
13497   if (p >= end)
13498     {
13499       warn (_("<corrupt tag>\n"));
13500     }
13501   else if (tag & 1)
13502     {
13503       /* PR 17531 file: 027-19978-0.004.  */
13504       size_t maxlen = (end - p) - 1;
13505
13506       putchar ('"');
13507       if (maxlen > 0)
13508         {
13509           print_symbol ((int) maxlen, (const char *) p);
13510           p += strnlen ((char *) p, maxlen) + 1;
13511         }
13512       else
13513         {
13514           printf (_("<corrupt string tag>"));
13515           p = (unsigned char *) end;
13516         }
13517       printf ("\"\n");
13518     }
13519   else
13520     {
13521       unsigned int len;
13522
13523       val = read_uleb128 (p, &len, end);
13524       p += len;
13525       printf ("%ld (0x%lx)\n", val, val);
13526     }
13527
13528   assert (p <= end);
13529   return p;
13530 }
13531
13532 /* ARC ABI attributes section.  */
13533
13534 static unsigned char *
13535 display_arc_attribute (unsigned char * p,
13536                        const unsigned char * const end)
13537 {
13538   unsigned int tag;
13539   unsigned int len;
13540   unsigned int val;
13541
13542   tag = read_uleb128 (p, &len, end);
13543   p += len;
13544
13545   switch (tag)
13546     {
13547     case Tag_ARC_PCS_config:
13548       val = read_uleb128 (p, &len, end);
13549       p += len;
13550       printf ("  Tag_ARC_PCS_config: ");
13551       switch (val)
13552         {
13553         case 0:
13554           printf (_("Absent/Non standard\n"));
13555           break;
13556         case 1:
13557           printf (_("Bare metal/mwdt\n"));
13558           break;
13559         case 2:
13560           printf (_("Bare metal/newlib\n"));
13561           break;
13562         case 3:
13563           printf (_("Linux/uclibc\n"));
13564           break;
13565         case 4:
13566           printf (_("Linux/glibc\n"));
13567           break;
13568         default:
13569           printf (_("Unknown\n"));
13570           break;
13571         }
13572       break;
13573
13574     case Tag_ARC_CPU_base:
13575       val = read_uleb128 (p, &len, end);
13576       p += len;
13577       printf ("  Tag_ARC_CPU_base: ");
13578       switch (val)
13579         {
13580         default:
13581         case TAG_CPU_NONE:
13582           printf (_("Absent\n"));
13583           break;
13584         case TAG_CPU_ARC6xx:
13585           printf ("ARC6xx\n");
13586           break;
13587         case TAG_CPU_ARC7xx:
13588           printf ("ARC7xx\n");
13589           break;
13590         case TAG_CPU_ARCEM:
13591           printf ("ARCEM\n");
13592           break;
13593         case TAG_CPU_ARCHS:
13594           printf ("ARCHS\n");
13595           break;
13596         }
13597       break;
13598
13599     case Tag_ARC_CPU_variation:
13600       val = read_uleb128 (p, &len, end);
13601       p += len;
13602       printf ("  Tag_ARC_CPU_variation: ");
13603       switch (val)
13604         {
13605         default:
13606           if (val > 0 && val < 16)
13607               printf ("Core%d\n", val);
13608           else
13609               printf ("Unknown\n");
13610           break;
13611
13612         case 0:
13613           printf (_("Absent\n"));
13614           break;
13615         }
13616       break;
13617
13618     case Tag_ARC_CPU_name:
13619       printf ("  Tag_ARC_CPU_name: ");
13620       p = display_tag_value (-1, p, end);
13621       break;
13622
13623     case Tag_ARC_ABI_rf16:
13624       val = read_uleb128 (p, &len, end);
13625       p += len;
13626       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13627       break;
13628
13629     case Tag_ARC_ABI_osver:
13630       val = read_uleb128 (p, &len, end);
13631       p += len;
13632       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13633       break;
13634
13635     case Tag_ARC_ABI_pic:
13636     case Tag_ARC_ABI_sda:
13637       val = read_uleb128 (p, &len, end);
13638       p += len;
13639       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13640               : "  Tag_ARC_ABI_pic: ");
13641       switch (val)
13642         {
13643         case 0:
13644           printf (_("Absent\n"));
13645           break;
13646         case 1:
13647           printf ("MWDT\n");
13648           break;
13649         case 2:
13650           printf ("GNU\n");
13651           break;
13652         default:
13653           printf (_("Unknown\n"));
13654           break;
13655         }
13656       break;
13657
13658     case Tag_ARC_ABI_tls:
13659       val = read_uleb128 (p, &len, end);
13660       p += len;
13661       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13662       break;
13663
13664     case Tag_ARC_ABI_enumsize:
13665       val = read_uleb128 (p, &len, end);
13666       p += len;
13667       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13668               _("smallest"));
13669       break;
13670
13671     case Tag_ARC_ABI_exceptions:
13672       val = read_uleb128 (p, &len, end);
13673       p += len;
13674       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13675               : _("default"));
13676       break;
13677
13678     case Tag_ARC_ABI_double_size:
13679       val = read_uleb128 (p, &len, end);
13680       p += len;
13681       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13682       break;
13683
13684     case Tag_ARC_ISA_config:
13685       printf ("  Tag_ARC_ISA_config: ");
13686       p = display_tag_value (-1, p, end);
13687       break;
13688
13689     case Tag_ARC_ISA_apex:
13690       printf ("  Tag_ARC_ISA_apex: ");
13691       p = display_tag_value (-1, p, end);
13692       break;
13693
13694     case Tag_ARC_ISA_mpy_option:
13695       val = read_uleb128 (p, &len, end);
13696       p += len;
13697       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13698       break;
13699
13700     default:
13701       return display_tag_value (tag & 1, p, end);
13702     }
13703
13704   return p;
13705 }
13706
13707 /* ARM EABI attributes section.  */
13708 typedef struct
13709 {
13710   unsigned int tag;
13711   const char * name;
13712   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13713   unsigned int type;
13714   const char ** table;
13715 } arm_attr_public_tag;
13716
13717 static const char * arm_attr_tag_CPU_arch[] =
13718   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13719    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13720    "v8-M.mainline"};
13721 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13722 static const char * arm_attr_tag_THUMB_ISA_use[] =
13723   {"No", "Thumb-1", "Thumb-2", "Yes"};
13724 static const char * arm_attr_tag_FP_arch[] =
13725   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13726    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13727 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13728 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13729   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13730    "NEON for ARMv8.1"};
13731 static const char * arm_attr_tag_PCS_config[] =
13732   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13733    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13734 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13735   {"V6", "SB", "TLS", "Unused"};
13736 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13737   {"Absolute", "PC-relative", "SB-relative", "None"};
13738 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13739   {"Absolute", "PC-relative", "None"};
13740 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13741   {"None", "direct", "GOT-indirect"};
13742 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13743   {"None", "??? 1", "2", "??? 3", "4"};
13744 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13745 static const char * arm_attr_tag_ABI_FP_denormal[] =
13746   {"Unused", "Needed", "Sign only"};
13747 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13748 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13749 static const char * arm_attr_tag_ABI_FP_number_model[] =
13750   {"Unused", "Finite", "RTABI", "IEEE 754"};
13751 static const char * arm_attr_tag_ABI_enum_size[] =
13752   {"Unused", "small", "int", "forced to int"};
13753 static const char * arm_attr_tag_ABI_HardFP_use[] =
13754   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13755 static const char * arm_attr_tag_ABI_VFP_args[] =
13756   {"AAPCS", "VFP registers", "custom", "compatible"};
13757 static const char * arm_attr_tag_ABI_WMMX_args[] =
13758   {"AAPCS", "WMMX registers", "custom"};
13759 static const char * arm_attr_tag_ABI_optimization_goals[] =
13760   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13761     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13762 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13763   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13764     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13765 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13766 static const char * arm_attr_tag_FP_HP_extension[] =
13767   {"Not Allowed", "Allowed"};
13768 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13769   {"None", "IEEE 754", "Alternative Format"};
13770 static const char * arm_attr_tag_DSP_extension[] =
13771   {"Follow architecture", "Allowed"};
13772 static const char * arm_attr_tag_MPextension_use[] =
13773   {"Not Allowed", "Allowed"};
13774 static const char * arm_attr_tag_DIV_use[] =
13775   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13776     "Allowed in v7-A with integer division extension"};
13777 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13778 static const char * arm_attr_tag_Virtualization_use[] =
13779   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13780     "TrustZone and Virtualization Extensions"};
13781 static const char * arm_attr_tag_MPextension_use_legacy[] =
13782   {"Not Allowed", "Allowed"};
13783
13784 #define LOOKUP(id, name) \
13785   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13786 static arm_attr_public_tag arm_attr_public_tags[] =
13787 {
13788   {4, "CPU_raw_name", 1, NULL},
13789   {5, "CPU_name", 1, NULL},
13790   LOOKUP(6, CPU_arch),
13791   {7, "CPU_arch_profile", 0, NULL},
13792   LOOKUP(8, ARM_ISA_use),
13793   LOOKUP(9, THUMB_ISA_use),
13794   LOOKUP(10, FP_arch),
13795   LOOKUP(11, WMMX_arch),
13796   LOOKUP(12, Advanced_SIMD_arch),
13797   LOOKUP(13, PCS_config),
13798   LOOKUP(14, ABI_PCS_R9_use),
13799   LOOKUP(15, ABI_PCS_RW_data),
13800   LOOKUP(16, ABI_PCS_RO_data),
13801   LOOKUP(17, ABI_PCS_GOT_use),
13802   LOOKUP(18, ABI_PCS_wchar_t),
13803   LOOKUP(19, ABI_FP_rounding),
13804   LOOKUP(20, ABI_FP_denormal),
13805   LOOKUP(21, ABI_FP_exceptions),
13806   LOOKUP(22, ABI_FP_user_exceptions),
13807   LOOKUP(23, ABI_FP_number_model),
13808   {24, "ABI_align_needed", 0, NULL},
13809   {25, "ABI_align_preserved", 0, NULL},
13810   LOOKUP(26, ABI_enum_size),
13811   LOOKUP(27, ABI_HardFP_use),
13812   LOOKUP(28, ABI_VFP_args),
13813   LOOKUP(29, ABI_WMMX_args),
13814   LOOKUP(30, ABI_optimization_goals),
13815   LOOKUP(31, ABI_FP_optimization_goals),
13816   {32, "compatibility", 0, NULL},
13817   LOOKUP(34, CPU_unaligned_access),
13818   LOOKUP(36, FP_HP_extension),
13819   LOOKUP(38, ABI_FP_16bit_format),
13820   LOOKUP(42, MPextension_use),
13821   LOOKUP(44, DIV_use),
13822   LOOKUP(46, DSP_extension),
13823   {64, "nodefaults", 0, NULL},
13824   {65, "also_compatible_with", 0, NULL},
13825   LOOKUP(66, T2EE_use),
13826   {67, "conformance", 1, NULL},
13827   LOOKUP(68, Virtualization_use),
13828   LOOKUP(70, MPextension_use_legacy)
13829 };
13830 #undef LOOKUP
13831
13832 static unsigned char *
13833 display_arm_attribute (unsigned char * p,
13834                        const unsigned char * const end)
13835 {
13836   unsigned int tag;
13837   unsigned int len;
13838   unsigned int val;
13839   arm_attr_public_tag * attr;
13840   unsigned i;
13841   unsigned int type;
13842
13843   tag = read_uleb128 (p, &len, end);
13844   p += len;
13845   attr = NULL;
13846   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13847     {
13848       if (arm_attr_public_tags[i].tag == tag)
13849         {
13850           attr = &arm_attr_public_tags[i];
13851           break;
13852         }
13853     }
13854
13855   if (attr)
13856     {
13857       printf ("  Tag_%s: ", attr->name);
13858       switch (attr->type)
13859         {
13860         case 0:
13861           switch (tag)
13862             {
13863             case 7: /* Tag_CPU_arch_profile.  */
13864               val = read_uleb128 (p, &len, end);
13865               p += len;
13866               switch (val)
13867                 {
13868                 case 0: printf (_("None\n")); break;
13869                 case 'A': printf (_("Application\n")); break;
13870                 case 'R': printf (_("Realtime\n")); break;
13871                 case 'M': printf (_("Microcontroller\n")); break;
13872                 case 'S': printf (_("Application or Realtime\n")); break;
13873                 default: printf ("??? (%d)\n", val); break;
13874                 }
13875               break;
13876
13877             case 24: /* Tag_align_needed.  */
13878               val = read_uleb128 (p, &len, end);
13879               p += len;
13880               switch (val)
13881                 {
13882                 case 0: printf (_("None\n")); break;
13883                 case 1: printf (_("8-byte\n")); break;
13884                 case 2: printf (_("4-byte\n")); break;
13885                 case 3: printf ("??? 3\n"); break;
13886                 default:
13887                   if (val <= 12)
13888                     printf (_("8-byte and up to %d-byte extended\n"),
13889                             1 << val);
13890                   else
13891                     printf ("??? (%d)\n", val);
13892                   break;
13893                 }
13894               break;
13895
13896             case 25: /* Tag_align_preserved.  */
13897               val = read_uleb128 (p, &len, end);
13898               p += len;
13899               switch (val)
13900                 {
13901                 case 0: printf (_("None\n")); break;
13902                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13903                 case 2: printf (_("8-byte\n")); break;
13904                 case 3: printf ("??? 3\n"); break;
13905                 default:
13906                   if (val <= 12)
13907                     printf (_("8-byte and up to %d-byte extended\n"),
13908                             1 << val);
13909                   else
13910                     printf ("??? (%d)\n", val);
13911                   break;
13912                 }
13913               break;
13914
13915             case 32: /* Tag_compatibility.  */
13916               {
13917                 val = read_uleb128 (p, &len, end);
13918                 p += len;
13919                 printf (_("flag = %d, vendor = "), val);
13920                 if (p < end - 1)
13921                   {
13922                     size_t maxlen = (end - p) - 1;
13923
13924                     print_symbol ((int) maxlen, (const char *) p);
13925                     p += strnlen ((char *) p, maxlen) + 1;
13926                   }
13927                 else
13928                   {
13929                     printf (_("<corrupt>"));
13930                     p = (unsigned char *) end;
13931                   }
13932                 putchar ('\n');
13933               }
13934               break;
13935
13936             case 64: /* Tag_nodefaults.  */
13937               /* PR 17531: file: 001-505008-0.01.  */
13938               if (p < end)
13939                 p++;
13940               printf (_("True\n"));
13941               break;
13942
13943             case 65: /* Tag_also_compatible_with.  */
13944               val = read_uleb128 (p, &len, end);
13945               p += len;
13946               if (val == 6 /* Tag_CPU_arch.  */)
13947                 {
13948                   val = read_uleb128 (p, &len, end);
13949                   p += len;
13950                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13951                     printf ("??? (%d)\n", val);
13952                   else
13953                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13954                 }
13955               else
13956                 printf ("???\n");
13957               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13958                 ;
13959               break;
13960
13961             default:
13962               printf (_("<unknown: %d>\n"), tag);
13963               break;
13964             }
13965           return p;
13966
13967         case 1:
13968           return display_tag_value (-1, p, end);
13969         case 2:
13970           return display_tag_value (0, p, end);
13971
13972         default:
13973           assert (attr->type & 0x80);
13974           val = read_uleb128 (p, &len, end);
13975           p += len;
13976           type = attr->type & 0x7f;
13977           if (val >= type)
13978             printf ("??? (%d)\n", val);
13979           else
13980             printf ("%s\n", attr->table[val]);
13981           return p;
13982         }
13983     }
13984
13985   return display_tag_value (tag, p, end);
13986 }
13987
13988 static unsigned char *
13989 display_gnu_attribute (unsigned char * p,
13990                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13991                        const unsigned char * const end)
13992 {
13993   int tag;
13994   unsigned int len;
13995   unsigned int val;
13996
13997   tag = read_uleb128 (p, &len, end);
13998   p += len;
13999
14000   /* Tag_compatibility is the only generic GNU attribute defined at
14001      present.  */
14002   if (tag == 32)
14003     {
14004       val = read_uleb128 (p, &len, end);
14005       p += len;
14006
14007       printf (_("flag = %d, vendor = "), val);
14008       if (p == end)
14009         {
14010           printf (_("<corrupt>\n"));
14011           warn (_("corrupt vendor attribute\n"));
14012         }
14013       else
14014         {
14015           if (p < end - 1)
14016             {
14017               size_t maxlen = (end - p) - 1;
14018
14019               print_symbol ((int) maxlen, (const char *) p);
14020               p += strnlen ((char *) p, maxlen) + 1;
14021             }
14022           else
14023             {
14024               printf (_("<corrupt>"));
14025               p = (unsigned char *) end;
14026             }
14027           putchar ('\n');
14028         }
14029       return p;
14030     }
14031
14032   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14033     return display_proc_gnu_attribute (p, tag, end);
14034
14035   return display_tag_value (tag, p, end);
14036 }
14037
14038 static unsigned char *
14039 display_power_gnu_attribute (unsigned char * p,
14040                              unsigned int tag,
14041                              const unsigned char * const end)
14042 {
14043   unsigned int len;
14044   unsigned int val;
14045
14046   if (tag == Tag_GNU_Power_ABI_FP)
14047     {
14048       val = read_uleb128 (p, &len, end);
14049       p += len;
14050       printf ("  Tag_GNU_Power_ABI_FP: ");
14051       if (len == 0)
14052         {
14053           printf (_("<corrupt>\n"));
14054           return p;
14055         }
14056
14057       if (val > 15)
14058         printf ("(%#x), ", val);
14059
14060       switch (val & 3)
14061         {
14062         case 0:
14063           printf (_("unspecified hard/soft float, "));
14064           break;
14065         case 1:
14066           printf (_("hard float, "));
14067           break;
14068         case 2:
14069           printf (_("soft float, "));
14070           break;
14071         case 3:
14072           printf (_("single-precision hard float, "));
14073           break;
14074         }
14075
14076       switch (val & 0xC)
14077         {
14078         case 0:
14079           printf (_("unspecified long double\n"));
14080           break;
14081         case 4:
14082           printf (_("128-bit IBM long double\n"));
14083           break;
14084         case 8:
14085           printf (_("64-bit long double\n"));
14086           break;
14087         case 12:
14088           printf (_("128-bit IEEE long double\n"));
14089           break;
14090         }
14091       return p;
14092     }
14093
14094   if (tag == Tag_GNU_Power_ABI_Vector)
14095     {
14096       val = read_uleb128 (p, &len, end);
14097       p += len;
14098       printf ("  Tag_GNU_Power_ABI_Vector: ");
14099       if (len == 0)
14100         {
14101           printf (_("<corrupt>\n"));
14102           return p;
14103         }
14104
14105       if (val > 3)
14106         printf ("(%#x), ", val);
14107
14108       switch (val & 3)
14109         {
14110         case 0:
14111           printf (_("unspecified\n"));
14112           break;
14113         case 1:
14114           printf (_("generic\n"));
14115           break;
14116         case 2:
14117           printf ("AltiVec\n");
14118           break;
14119         case 3:
14120           printf ("SPE\n");
14121           break;
14122         }
14123       return p;
14124     }
14125
14126   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14127     {
14128       val = read_uleb128 (p, &len, end);
14129       p += len;
14130       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14131       if (len == 0)
14132         {
14133           printf (_("<corrupt>\n"));
14134           return p;
14135         }
14136
14137       if (val > 2)
14138         printf ("(%#x), ", val);
14139
14140       switch (val & 3)
14141         {
14142         case 0:
14143           printf (_("unspecified\n"));
14144           break;
14145         case 1:
14146           printf ("r3/r4\n");
14147           break;
14148         case 2:
14149           printf (_("memory\n"));
14150           break;
14151         case 3:
14152           printf ("???\n");
14153           break;
14154         }
14155       return p;
14156     }
14157
14158   return display_tag_value (tag & 1, p, end);
14159 }
14160
14161 static unsigned char *
14162 display_s390_gnu_attribute (unsigned char * p,
14163                             unsigned int tag,
14164                             const unsigned char * const end)
14165 {
14166   unsigned int len;
14167   int val;
14168
14169   if (tag == Tag_GNU_S390_ABI_Vector)
14170     {
14171       val = read_uleb128 (p, &len, end);
14172       p += len;
14173       printf ("  Tag_GNU_S390_ABI_Vector: ");
14174
14175       switch (val)
14176         {
14177         case 0:
14178           printf (_("any\n"));
14179           break;
14180         case 1:
14181           printf (_("software\n"));
14182           break;
14183         case 2:
14184           printf (_("hardware\n"));
14185           break;
14186         default:
14187           printf ("??? (%d)\n", val);
14188           break;
14189         }
14190       return p;
14191    }
14192
14193   return display_tag_value (tag & 1, p, end);
14194 }
14195
14196 static void
14197 display_sparc_hwcaps (unsigned int mask)
14198 {
14199   if (mask)
14200     {
14201       bfd_boolean first = TRUE;
14202
14203       if (mask & ELF_SPARC_HWCAP_MUL32)
14204         fputs ("mul32", stdout), first = FALSE;
14205       if (mask & ELF_SPARC_HWCAP_DIV32)
14206         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14207       if (mask & ELF_SPARC_HWCAP_FSMULD)
14208         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14209       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14210         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14211       if (mask & ELF_SPARC_HWCAP_POPC)
14212         printf ("%spopc", first ? "" : "|"), first = FALSE;
14213       if (mask & ELF_SPARC_HWCAP_VIS)
14214         printf ("%svis", first ? "" : "|"), first = FALSE;
14215       if (mask & ELF_SPARC_HWCAP_VIS2)
14216         printf ("%svis2", first ? "" : "|"), first = FALSE;
14217       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14218         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14219       if (mask & ELF_SPARC_HWCAP_FMAF)
14220         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14221       if (mask & ELF_SPARC_HWCAP_VIS3)
14222         printf ("%svis3", first ? "" : "|"), first = FALSE;
14223       if (mask & ELF_SPARC_HWCAP_HPC)
14224         printf ("%shpc", first ? "" : "|"), first = FALSE;
14225       if (mask & ELF_SPARC_HWCAP_RANDOM)
14226         printf ("%srandom", first ? "" : "|"), first = FALSE;
14227       if (mask & ELF_SPARC_HWCAP_TRANS)
14228         printf ("%strans", first ? "" : "|"), first = FALSE;
14229       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14230         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14231       if (mask & ELF_SPARC_HWCAP_IMA)
14232         printf ("%sima", first ? "" : "|"), first = FALSE;
14233       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14234         printf ("%scspare", first ? "" : "|"), first = FALSE;
14235     }
14236   else
14237     fputc ('0', stdout);
14238   fputc ('\n', stdout);
14239 }
14240
14241 static void
14242 display_sparc_hwcaps2 (unsigned int mask)
14243 {
14244   if (mask)
14245     {
14246       bfd_boolean first = TRUE;
14247
14248       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14249         fputs ("fjathplus", stdout), first = FALSE;
14250       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14251         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14252       if (mask & ELF_SPARC_HWCAP2_ADP)
14253         printf ("%sadp", first ? "" : "|"), first = FALSE;
14254       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14255         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14256       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14257         printf ("%smwait", first ? "" : "|"), first = FALSE;
14258       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14259         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14260       if (mask & ELF_SPARC_HWCAP2_XMONT)
14261         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14262       if (mask & ELF_SPARC_HWCAP2_NSEC)
14263         printf ("%snsec", first ? "" : "|"), first = FALSE;
14264       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14265         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14266       if (mask & ELF_SPARC_HWCAP2_FJDES)
14267         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14268       if (mask & ELF_SPARC_HWCAP2_FJAES)
14269         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14270     }
14271   else
14272     fputc ('0', stdout);
14273   fputc ('\n', stdout);
14274 }
14275
14276 static unsigned char *
14277 display_sparc_gnu_attribute (unsigned char * p,
14278                              unsigned int tag,
14279                              const unsigned char * const end)
14280 {
14281   unsigned int len;
14282   int val;
14283
14284   if (tag == Tag_GNU_Sparc_HWCAPS)
14285     {
14286       val = read_uleb128 (p, &len, end);
14287       p += len;
14288       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14289       display_sparc_hwcaps (val);
14290       return p;
14291     }
14292   if (tag == Tag_GNU_Sparc_HWCAPS2)
14293     {
14294       val = read_uleb128 (p, &len, end);
14295       p += len;
14296       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14297       display_sparc_hwcaps2 (val);
14298       return p;
14299     }
14300
14301   return display_tag_value (tag, p, end);
14302 }
14303
14304 static void
14305 print_mips_fp_abi_value (unsigned int val)
14306 {
14307   switch (val)
14308     {
14309     case Val_GNU_MIPS_ABI_FP_ANY:
14310       printf (_("Hard or soft float\n"));
14311       break;
14312     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14313       printf (_("Hard float (double precision)\n"));
14314       break;
14315     case Val_GNU_MIPS_ABI_FP_SINGLE:
14316       printf (_("Hard float (single precision)\n"));
14317       break;
14318     case Val_GNU_MIPS_ABI_FP_SOFT:
14319       printf (_("Soft float\n"));
14320       break;
14321     case Val_GNU_MIPS_ABI_FP_OLD_64:
14322       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14323       break;
14324     case Val_GNU_MIPS_ABI_FP_XX:
14325       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14326       break;
14327     case Val_GNU_MIPS_ABI_FP_64:
14328       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14329       break;
14330     case Val_GNU_MIPS_ABI_FP_64A:
14331       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14332       break;
14333     case Val_GNU_MIPS_ABI_FP_NAN2008:
14334       printf (_("NaN 2008 compatibility\n"));
14335       break;
14336     default:
14337       printf ("??? (%d)\n", val);
14338       break;
14339     }
14340 }
14341
14342 static unsigned char *
14343 display_mips_gnu_attribute (unsigned char * p,
14344                             unsigned int tag,
14345                             const unsigned char * const end)
14346 {
14347   if (tag == Tag_GNU_MIPS_ABI_FP)
14348     {
14349       unsigned int len;
14350       unsigned int val;
14351
14352       val = read_uleb128 (p, &len, end);
14353       p += len;
14354       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14355
14356       print_mips_fp_abi_value (val);
14357
14358       return p;
14359    }
14360
14361   if (tag == Tag_GNU_MIPS_ABI_MSA)
14362     {
14363       unsigned int len;
14364       unsigned int val;
14365
14366       val = read_uleb128 (p, &len, end);
14367       p += len;
14368       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14369
14370       switch (val)
14371         {
14372         case Val_GNU_MIPS_ABI_MSA_ANY:
14373           printf (_("Any MSA or not\n"));
14374           break;
14375         case Val_GNU_MIPS_ABI_MSA_128:
14376           printf (_("128-bit MSA\n"));
14377           break;
14378         default:
14379           printf ("??? (%d)\n", val);
14380           break;
14381         }
14382       return p;
14383     }
14384
14385   return display_tag_value (tag & 1, p, end);
14386 }
14387
14388 static unsigned char *
14389 display_tic6x_attribute (unsigned char * p,
14390                          const unsigned char * const end)
14391 {
14392   unsigned int tag;
14393   unsigned int len;
14394   int val;
14395
14396   tag = read_uleb128 (p, &len, end);
14397   p += len;
14398
14399   switch (tag)
14400     {
14401     case Tag_ISA:
14402       val = read_uleb128 (p, &len, end);
14403       p += len;
14404       printf ("  Tag_ISA: ");
14405
14406       switch (val)
14407         {
14408         case C6XABI_Tag_ISA_none:
14409           printf (_("None\n"));
14410           break;
14411         case C6XABI_Tag_ISA_C62X:
14412           printf ("C62x\n");
14413           break;
14414         case C6XABI_Tag_ISA_C67X:
14415           printf ("C67x\n");
14416           break;
14417         case C6XABI_Tag_ISA_C67XP:
14418           printf ("C67x+\n");
14419           break;
14420         case C6XABI_Tag_ISA_C64X:
14421           printf ("C64x\n");
14422           break;
14423         case C6XABI_Tag_ISA_C64XP:
14424           printf ("C64x+\n");
14425           break;
14426         case C6XABI_Tag_ISA_C674X:
14427           printf ("C674x\n");
14428           break;
14429         default:
14430           printf ("??? (%d)\n", val);
14431           break;
14432         }
14433       return p;
14434
14435     case Tag_ABI_wchar_t:
14436       val = read_uleb128 (p, &len, end);
14437       p += len;
14438       printf ("  Tag_ABI_wchar_t: ");
14439       switch (val)
14440         {
14441         case 0:
14442           printf (_("Not used\n"));
14443           break;
14444         case 1:
14445           printf (_("2 bytes\n"));
14446           break;
14447         case 2:
14448           printf (_("4 bytes\n"));
14449           break;
14450         default:
14451           printf ("??? (%d)\n", val);
14452           break;
14453         }
14454       return p;
14455
14456     case Tag_ABI_stack_align_needed:
14457       val = read_uleb128 (p, &len, end);
14458       p += len;
14459       printf ("  Tag_ABI_stack_align_needed: ");
14460       switch (val)
14461         {
14462         case 0:
14463           printf (_("8-byte\n"));
14464           break;
14465         case 1:
14466           printf (_("16-byte\n"));
14467           break;
14468         default:
14469           printf ("??? (%d)\n", val);
14470           break;
14471         }
14472       return p;
14473
14474     case Tag_ABI_stack_align_preserved:
14475       val = read_uleb128 (p, &len, end);
14476       p += len;
14477       printf ("  Tag_ABI_stack_align_preserved: ");
14478       switch (val)
14479         {
14480         case 0:
14481           printf (_("8-byte\n"));
14482           break;
14483         case 1:
14484           printf (_("16-byte\n"));
14485           break;
14486         default:
14487           printf ("??? (%d)\n", val);
14488           break;
14489         }
14490       return p;
14491
14492     case Tag_ABI_DSBT:
14493       val = read_uleb128 (p, &len, end);
14494       p += len;
14495       printf ("  Tag_ABI_DSBT: ");
14496       switch (val)
14497         {
14498         case 0:
14499           printf (_("DSBT addressing not used\n"));
14500           break;
14501         case 1:
14502           printf (_("DSBT addressing used\n"));
14503           break;
14504         default:
14505           printf ("??? (%d)\n", val);
14506           break;
14507         }
14508       return p;
14509
14510     case Tag_ABI_PID:
14511       val = read_uleb128 (p, &len, end);
14512       p += len;
14513       printf ("  Tag_ABI_PID: ");
14514       switch (val)
14515         {
14516         case 0:
14517           printf (_("Data addressing position-dependent\n"));
14518           break;
14519         case 1:
14520           printf (_("Data addressing position-independent, GOT near DP\n"));
14521           break;
14522         case 2:
14523           printf (_("Data addressing position-independent, GOT far from DP\n"));
14524           break;
14525         default:
14526           printf ("??? (%d)\n", val);
14527           break;
14528         }
14529       return p;
14530
14531     case Tag_ABI_PIC:
14532       val = read_uleb128 (p, &len, end);
14533       p += len;
14534       printf ("  Tag_ABI_PIC: ");
14535       switch (val)
14536         {
14537         case 0:
14538           printf (_("Code addressing position-dependent\n"));
14539           break;
14540         case 1:
14541           printf (_("Code addressing position-independent\n"));
14542           break;
14543         default:
14544           printf ("??? (%d)\n", val);
14545           break;
14546         }
14547       return p;
14548
14549     case Tag_ABI_array_object_alignment:
14550       val = read_uleb128 (p, &len, end);
14551       p += len;
14552       printf ("  Tag_ABI_array_object_alignment: ");
14553       switch (val)
14554         {
14555         case 0:
14556           printf (_("8-byte\n"));
14557           break;
14558         case 1:
14559           printf (_("4-byte\n"));
14560           break;
14561         case 2:
14562           printf (_("16-byte\n"));
14563           break;
14564         default:
14565           printf ("??? (%d)\n", val);
14566           break;
14567         }
14568       return p;
14569
14570     case Tag_ABI_array_object_align_expected:
14571       val = read_uleb128 (p, &len, end);
14572       p += len;
14573       printf ("  Tag_ABI_array_object_align_expected: ");
14574       switch (val)
14575         {
14576         case 0:
14577           printf (_("8-byte\n"));
14578           break;
14579         case 1:
14580           printf (_("4-byte\n"));
14581           break;
14582         case 2:
14583           printf (_("16-byte\n"));
14584           break;
14585         default:
14586           printf ("??? (%d)\n", val);
14587           break;
14588         }
14589       return p;
14590
14591     case Tag_ABI_compatibility:
14592       {
14593         val = read_uleb128 (p, &len, end);
14594         p += len;
14595         printf ("  Tag_ABI_compatibility: ");
14596         printf (_("flag = %d, vendor = "), val);
14597         if (p < end - 1)
14598           {
14599             size_t maxlen = (end - p) - 1;
14600
14601             print_symbol ((int) maxlen, (const char *) p);
14602             p += strnlen ((char *) p, maxlen) + 1;
14603           }
14604         else
14605           {
14606             printf (_("<corrupt>"));
14607             p = (unsigned char *) end;
14608           }
14609         putchar ('\n');
14610         return p;
14611       }
14612
14613     case Tag_ABI_conformance:
14614       {
14615         printf ("  Tag_ABI_conformance: \"");
14616         if (p < end - 1)
14617           {
14618             size_t maxlen = (end - p) - 1;
14619
14620             print_symbol ((int) maxlen, (const char *) p);
14621             p += strnlen ((char *) p, maxlen) + 1;
14622           }
14623         else
14624           {
14625             printf (_("<corrupt>"));
14626             p = (unsigned char *) end;
14627           }
14628         printf ("\"\n");
14629         return p;
14630       }
14631     }
14632
14633   return display_tag_value (tag, p, end);
14634 }
14635
14636 static void
14637 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14638 {
14639   unsigned long addr = 0;
14640   size_t bytes = end - p;
14641
14642   assert (end > p);
14643   while (bytes)
14644     {
14645       int j;
14646       int k;
14647       int lbytes = (bytes > 16 ? 16 : bytes);
14648
14649       printf ("  0x%8.8lx ", addr);
14650
14651       for (j = 0; j < 16; j++)
14652         {
14653           if (j < lbytes)
14654             printf ("%2.2x", p[j]);
14655           else
14656             printf ("  ");
14657
14658           if ((j & 3) == 3)
14659             printf (" ");
14660         }
14661
14662       for (j = 0; j < lbytes; j++)
14663         {
14664           k = p[j];
14665           if (k >= ' ' && k < 0x7f)
14666             printf ("%c", k);
14667           else
14668             printf (".");
14669         }
14670
14671       putchar ('\n');
14672
14673       p  += lbytes;
14674       bytes -= lbytes;
14675       addr += lbytes;
14676     }
14677
14678   putchar ('\n');
14679 }
14680
14681 static unsigned char *
14682 display_msp430x_attribute (unsigned char * p,
14683                            const unsigned char * const end)
14684 {
14685   unsigned int len;
14686   unsigned int val;
14687   unsigned int tag;
14688
14689   tag = read_uleb128 (p, & len, end);
14690   p += len;
14691
14692   switch (tag)
14693     {
14694     case OFBA_MSPABI_Tag_ISA:
14695       val = read_uleb128 (p, &len, end);
14696       p += len;
14697       printf ("  Tag_ISA: ");
14698       switch (val)
14699         {
14700         case 0: printf (_("None\n")); break;
14701         case 1: printf (_("MSP430\n")); break;
14702         case 2: printf (_("MSP430X\n")); break;
14703         default: printf ("??? (%d)\n", val); break;
14704         }
14705       break;
14706
14707     case OFBA_MSPABI_Tag_Code_Model:
14708       val = read_uleb128 (p, &len, end);
14709       p += len;
14710       printf ("  Tag_Code_Model: ");
14711       switch (val)
14712         {
14713         case 0: printf (_("None\n")); break;
14714         case 1: printf (_("Small\n")); break;
14715         case 2: printf (_("Large\n")); break;
14716         default: printf ("??? (%d)\n", val); break;
14717         }
14718       break;
14719
14720     case OFBA_MSPABI_Tag_Data_Model:
14721       val = read_uleb128 (p, &len, end);
14722       p += len;
14723       printf ("  Tag_Data_Model: ");
14724       switch (val)
14725         {
14726         case 0: printf (_("None\n")); break;
14727         case 1: printf (_("Small\n")); break;
14728         case 2: printf (_("Large\n")); break;
14729         case 3: printf (_("Restricted Large\n")); break;
14730         default: printf ("??? (%d)\n", val); break;
14731         }
14732       break;
14733
14734     default:
14735       printf (_("  <unknown tag %d>: "), tag);
14736
14737       if (tag & 1)
14738         {
14739           putchar ('"');
14740           if (p < end - 1)
14741             {
14742               size_t maxlen = (end - p) - 1;
14743
14744               print_symbol ((int) maxlen, (const char *) p);
14745               p += strnlen ((char *) p, maxlen) + 1;
14746             }
14747           else
14748             {
14749               printf (_("<corrupt>"));
14750               p = (unsigned char *) end;
14751             }
14752           printf ("\"\n");
14753         }
14754       else
14755         {
14756           val = read_uleb128 (p, &len, end);
14757           p += len;
14758           printf ("%d (0x%x)\n", val, val);
14759         }
14760       break;
14761    }
14762
14763   assert (p <= end);
14764   return p;
14765 }
14766
14767 static bfd_boolean
14768 process_attributes (FILE * file,
14769                     const char * public_name,
14770                     unsigned int proc_type,
14771                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14772                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14773 {
14774   Elf_Internal_Shdr * sect;
14775   unsigned i;
14776   bfd_boolean res = TRUE;
14777
14778   /* Find the section header so that we get the size.  */
14779   for (i = 0, sect = section_headers;
14780        i < elf_header.e_shnum;
14781        i++, sect++)
14782     {
14783       unsigned char * contents;
14784       unsigned char * p;
14785
14786       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14787         continue;
14788
14789       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14790                                              sect->sh_size, _("attributes"));
14791       if (contents == NULL)
14792         {
14793           res = FALSE;
14794           continue;
14795         }
14796
14797       p = contents;
14798       /* The first character is the version of the attributes.
14799          Currently only version 1, (aka 'A') is recognised here.  */
14800       if (*p != 'A')
14801         {
14802           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14803           res = FALSE;
14804         }
14805       else
14806         {
14807           bfd_vma section_len;
14808
14809           section_len = sect->sh_size - 1;
14810           p++;
14811
14812           while (section_len > 0)
14813             {
14814               bfd_vma attr_len;
14815               unsigned int namelen;
14816               bfd_boolean public_section;
14817               bfd_boolean gnu_section;
14818
14819               if (section_len <= 4)
14820                 {
14821                   error (_("Tag section ends prematurely\n"));
14822                   res = FALSE;
14823                   break;
14824                 }
14825               attr_len = byte_get (p, 4);
14826               p += 4;
14827
14828               if (attr_len > section_len)
14829                 {
14830                   error (_("Bad attribute length (%u > %u)\n"),
14831                           (unsigned) attr_len, (unsigned) section_len);
14832                   attr_len = section_len;
14833                   res = FALSE;
14834                 }
14835               /* PR 17531: file: 001-101425-0.004  */
14836               else if (attr_len < 5)
14837                 {
14838                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14839                   res = FALSE;
14840                   break;
14841                 }
14842
14843               section_len -= attr_len;
14844               attr_len -= 4;
14845
14846               namelen = strnlen ((char *) p, attr_len) + 1;
14847               if (namelen == 0 || namelen >= attr_len)
14848                 {
14849                   error (_("Corrupt attribute section name\n"));
14850                   res = FALSE;
14851                   break;
14852                 }
14853
14854               printf (_("Attribute Section: "));
14855               print_symbol (INT_MAX, (const char *) p);
14856               putchar ('\n');
14857
14858               if (public_name && streq ((char *) p, public_name))
14859                 public_section = TRUE;
14860               else
14861                 public_section = FALSE;
14862
14863               if (streq ((char *) p, "gnu"))
14864                 gnu_section = TRUE;
14865               else
14866                 gnu_section = FALSE;
14867
14868               p += namelen;
14869               attr_len -= namelen;
14870
14871               while (attr_len > 0 && p < contents + sect->sh_size)
14872                 {
14873                   int tag;
14874                   int val;
14875                   bfd_vma size;
14876                   unsigned char * end;
14877
14878                   /* PR binutils/17531: Safe handling of corrupt files.  */
14879                   if (attr_len < 6)
14880                     {
14881                       error (_("Unused bytes at end of section\n"));
14882                       res = FALSE;
14883                       section_len = 0;
14884                       break;
14885                     }
14886
14887                   tag = *(p++);
14888                   size = byte_get (p, 4);
14889                   if (size > attr_len)
14890                     {
14891                       error (_("Bad subsection length (%u > %u)\n"),
14892                               (unsigned) size, (unsigned) attr_len);
14893                       res = FALSE;
14894                       size = attr_len;
14895                     }
14896                   /* PR binutils/17531: Safe handling of corrupt files.  */
14897                   if (size < 6)
14898                     {
14899                       error (_("Bad subsection length (%u < 6)\n"),
14900                               (unsigned) size);
14901                       res = FALSE;
14902                       section_len = 0;
14903                       break;
14904                     }
14905
14906                   attr_len -= size;
14907                   end = p + size - 1;
14908                   assert (end <= contents + sect->sh_size);
14909                   p += 4;
14910
14911                   switch (tag)
14912                     {
14913                     case 1:
14914                       printf (_("File Attributes\n"));
14915                       break;
14916                     case 2:
14917                       printf (_("Section Attributes:"));
14918                       goto do_numlist;
14919                     case 3:
14920                       printf (_("Symbol Attributes:"));
14921                       /* Fall through.  */
14922                     do_numlist:
14923                       for (;;)
14924                         {
14925                           unsigned int j;
14926
14927                           val = read_uleb128 (p, &j, end);
14928                           p += j;
14929                           if (val == 0)
14930                             break;
14931                           printf (" %d", val);
14932                         }
14933                       printf ("\n");
14934                       break;
14935                     default:
14936                       printf (_("Unknown tag: %d\n"), tag);
14937                       public_section = FALSE;
14938                       break;
14939                     }
14940
14941                   if (public_section && display_pub_attribute != NULL)
14942                     {
14943                       while (p < end)
14944                         p = display_pub_attribute (p, end);
14945                       assert (p == end);
14946                     }
14947                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14948                     {
14949                       while (p < end)
14950                         p = display_gnu_attribute (p,
14951                                                    display_proc_gnu_attribute,
14952                                                    end);
14953                       assert (p == end);
14954                     }
14955                   else if (p < end)
14956                     {
14957                       printf (_("  Unknown attribute:\n"));
14958                       display_raw_attribute (p, end);
14959                       p = end;
14960                     }
14961                   else
14962                     attr_len = 0;
14963                 }
14964             }
14965         }
14966
14967       free (contents);
14968     }
14969
14970   return res;
14971 }
14972
14973 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14974    Print the Address, Access and Initial fields of an entry at VMA ADDR
14975    and return the VMA of the next entry, or -1 if there was a problem.
14976    Does not read from DATA_END or beyond.  */
14977
14978 static bfd_vma
14979 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14980                       unsigned char * data_end)
14981 {
14982   printf ("  ");
14983   print_vma (addr, LONG_HEX);
14984   printf (" ");
14985   if (addr < pltgot + 0xfff0)
14986     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14987   else
14988     printf ("%10s", "");
14989   printf (" ");
14990   if (data == NULL)
14991     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14992   else
14993     {
14994       bfd_vma entry;
14995       unsigned char * from = data + addr - pltgot;
14996
14997       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14998         {
14999           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15000           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15001           return (bfd_vma) -1;
15002         }
15003       else
15004         {
15005           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15006           print_vma (entry, LONG_HEX);
15007         }
15008     }
15009   return addr + (is_32bit_elf ? 4 : 8);
15010 }
15011
15012 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15013    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15014    ADDR and return the VMA of the next entry.  */
15015
15016 static bfd_vma
15017 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15018 {
15019   printf ("  ");
15020   print_vma (addr, LONG_HEX);
15021   printf (" ");
15022   if (data == NULL)
15023     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15024   else
15025     {
15026       bfd_vma entry;
15027
15028       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15029       print_vma (entry, LONG_HEX);
15030     }
15031   return addr + (is_32bit_elf ? 4 : 8);
15032 }
15033
15034 static void
15035 print_mips_ases (unsigned int mask)
15036 {
15037   if (mask & AFL_ASE_DSP)
15038     fputs ("\n\tDSP ASE", stdout);
15039   if (mask & AFL_ASE_DSPR2)
15040     fputs ("\n\tDSP R2 ASE", stdout);
15041   if (mask & AFL_ASE_DSPR3)
15042     fputs ("\n\tDSP R3 ASE", stdout);
15043   if (mask & AFL_ASE_EVA)
15044     fputs ("\n\tEnhanced VA Scheme", stdout);
15045   if (mask & AFL_ASE_MCU)
15046     fputs ("\n\tMCU (MicroController) ASE", stdout);
15047   if (mask & AFL_ASE_MDMX)
15048     fputs ("\n\tMDMX ASE", stdout);
15049   if (mask & AFL_ASE_MIPS3D)
15050     fputs ("\n\tMIPS-3D ASE", stdout);
15051   if (mask & AFL_ASE_MT)
15052     fputs ("\n\tMT ASE", stdout);
15053   if (mask & AFL_ASE_SMARTMIPS)
15054     fputs ("\n\tSmartMIPS ASE", stdout);
15055   if (mask & AFL_ASE_VIRT)
15056     fputs ("\n\tVZ ASE", stdout);
15057   if (mask & AFL_ASE_MSA)
15058     fputs ("\n\tMSA ASE", stdout);
15059   if (mask & AFL_ASE_MIPS16)
15060     fputs ("\n\tMIPS16 ASE", stdout);
15061   if (mask & AFL_ASE_MICROMIPS)
15062     fputs ("\n\tMICROMIPS ASE", stdout);
15063   if (mask & AFL_ASE_XPA)
15064     fputs ("\n\tXPA ASE", stdout);
15065   if (mask & AFL_ASE_MIPS16E2)
15066     fputs ("\n\tMIPS16e2 ASE", stdout);
15067   if (mask == 0)
15068     fprintf (stdout, "\n\t%s", _("None"));
15069   else if ((mask & ~AFL_ASE_MASK) != 0)
15070     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15071 }
15072
15073 static void
15074 print_mips_isa_ext (unsigned int isa_ext)
15075 {
15076   switch (isa_ext)
15077     {
15078     case 0:
15079       fputs (_("None"), stdout);
15080       break;
15081     case AFL_EXT_XLR:
15082       fputs ("RMI XLR", stdout);
15083       break;
15084     case AFL_EXT_OCTEON3:
15085       fputs ("Cavium Networks Octeon3", stdout);
15086       break;
15087     case AFL_EXT_OCTEON2:
15088       fputs ("Cavium Networks Octeon2", stdout);
15089       break;
15090     case AFL_EXT_OCTEONP:
15091       fputs ("Cavium Networks OcteonP", stdout);
15092       break;
15093     case AFL_EXT_LOONGSON_3A:
15094       fputs ("Loongson 3A", stdout);
15095       break;
15096     case AFL_EXT_OCTEON:
15097       fputs ("Cavium Networks Octeon", stdout);
15098       break;
15099     case AFL_EXT_5900:
15100       fputs ("Toshiba R5900", stdout);
15101       break;
15102     case AFL_EXT_4650:
15103       fputs ("MIPS R4650", stdout);
15104       break;
15105     case AFL_EXT_4010:
15106       fputs ("LSI R4010", stdout);
15107       break;
15108     case AFL_EXT_4100:
15109       fputs ("NEC VR4100", stdout);
15110       break;
15111     case AFL_EXT_3900:
15112       fputs ("Toshiba R3900", stdout);
15113       break;
15114     case AFL_EXT_10000:
15115       fputs ("MIPS R10000", stdout);
15116       break;
15117     case AFL_EXT_SB1:
15118       fputs ("Broadcom SB-1", stdout);
15119       break;
15120     case AFL_EXT_4111:
15121       fputs ("NEC VR4111/VR4181", stdout);
15122       break;
15123     case AFL_EXT_4120:
15124       fputs ("NEC VR4120", stdout);
15125       break;
15126     case AFL_EXT_5400:
15127       fputs ("NEC VR5400", stdout);
15128       break;
15129     case AFL_EXT_5500:
15130       fputs ("NEC VR5500", stdout);
15131       break;
15132     case AFL_EXT_LOONGSON_2E:
15133       fputs ("ST Microelectronics Loongson 2E", stdout);
15134       break;
15135     case AFL_EXT_LOONGSON_2F:
15136       fputs ("ST Microelectronics Loongson 2F", stdout);
15137       break;
15138     case AFL_EXT_INTERAPTIV_MR2:
15139       fputs ("Imagination interAptiv MR2", stdout);
15140       break;
15141     default:
15142       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15143     }
15144 }
15145
15146 static signed int
15147 get_mips_reg_size (int reg_size)
15148 {
15149   return (reg_size == AFL_REG_NONE) ? 0
15150          : (reg_size == AFL_REG_32) ? 32
15151          : (reg_size == AFL_REG_64) ? 64
15152          : (reg_size == AFL_REG_128) ? 128
15153          : -1;
15154 }
15155
15156 static bfd_boolean
15157 process_mips_specific (FILE * file)
15158 {
15159   Elf_Internal_Dyn * entry;
15160   Elf_Internal_Shdr *sect = NULL;
15161   size_t liblist_offset = 0;
15162   size_t liblistno = 0;
15163   size_t conflictsno = 0;
15164   size_t options_offset = 0;
15165   size_t conflicts_offset = 0;
15166   size_t pltrelsz = 0;
15167   size_t pltrel = 0;
15168   bfd_vma pltgot = 0;
15169   bfd_vma mips_pltgot = 0;
15170   bfd_vma jmprel = 0;
15171   bfd_vma local_gotno = 0;
15172   bfd_vma gotsym = 0;
15173   bfd_vma symtabno = 0;
15174   bfd_boolean res = TRUE;
15175
15176   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15177                             display_mips_gnu_attribute))
15178     res = FALSE;
15179
15180   sect = find_section (".MIPS.abiflags");
15181
15182   if (sect != NULL)
15183     {
15184       Elf_External_ABIFlags_v0 *abiflags_ext;
15185       Elf_Internal_ABIFlags_v0 abiflags_in;
15186
15187       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15188         {
15189           error (_("Corrupt MIPS ABI Flags section.\n"));
15190           res = FALSE;
15191         }
15192       else
15193         {
15194           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15195                                    sect->sh_size, _("MIPS ABI Flags section"));
15196           if (abiflags_ext)
15197             {
15198               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15199               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15200               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15201               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15202               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15203               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15204               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15205               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15206               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15207               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15208               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15209
15210               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15211               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15212               if (abiflags_in.isa_rev > 1)
15213                 printf ("r%d", abiflags_in.isa_rev);
15214               printf ("\nGPR size: %d",
15215                       get_mips_reg_size (abiflags_in.gpr_size));
15216               printf ("\nCPR1 size: %d",
15217                       get_mips_reg_size (abiflags_in.cpr1_size));
15218               printf ("\nCPR2 size: %d",
15219                       get_mips_reg_size (abiflags_in.cpr2_size));
15220               fputs ("\nFP ABI: ", stdout);
15221               print_mips_fp_abi_value (abiflags_in.fp_abi);
15222               fputs ("ISA Extension: ", stdout);
15223               print_mips_isa_ext (abiflags_in.isa_ext);
15224               fputs ("\nASEs:", stdout);
15225               print_mips_ases (abiflags_in.ases);
15226               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15227               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15228               fputc ('\n', stdout);
15229               free (abiflags_ext);
15230             }
15231         }
15232     }
15233
15234   /* We have a lot of special sections.  Thanks SGI!  */
15235   if (dynamic_section == NULL)
15236     {
15237       /* No dynamic information available.  See if there is static GOT.  */
15238       sect = find_section (".got");
15239       if (sect != NULL)
15240         {
15241           unsigned char *data_end;
15242           unsigned char *data;
15243           bfd_vma ent, end;
15244           int addr_size;
15245
15246           pltgot = sect->sh_addr;
15247
15248           ent = pltgot;
15249           addr_size = (is_32bit_elf ? 4 : 8);
15250           end = pltgot + sect->sh_size;
15251
15252           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15253                                              end - pltgot, 1,
15254                                              _("Global Offset Table data"));
15255           /* PR 12855: Null data is handled gracefully throughout.  */
15256           data_end = data + (end - pltgot);
15257
15258           printf (_("\nStatic GOT:\n"));
15259           printf (_(" Canonical gp value: "));
15260           print_vma (ent + 0x7ff0, LONG_HEX);
15261           printf ("\n\n");
15262
15263           /* In a dynamic binary GOT[0] is reserved for the dynamic
15264              loader to store the lazy resolver pointer, however in
15265              a static binary it may well have been omitted and GOT
15266              reduced to a table of addresses.
15267              PR 21344: Check for the entry being fully available
15268              before fetching it.  */
15269           if (data
15270               && data + ent - pltgot + addr_size <= data_end
15271               && byte_get (data + ent - pltgot, addr_size) == 0)
15272             {
15273               printf (_(" Reserved entries:\n"));
15274               printf (_("  %*s %10s %*s\n"),
15275                       addr_size * 2, _("Address"), _("Access"),
15276                       addr_size * 2, _("Value"));
15277               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15278               printf ("\n");
15279               if (ent == (bfd_vma) -1)
15280                 goto sgot_print_fail;
15281
15282               /* Check for the MSB of GOT[1] being set, identifying a
15283                  GNU object.  This entry will be used by some runtime
15284                  loaders, to store the module pointer.  Otherwise this
15285                  is an ordinary local entry.
15286                  PR 21344: Check for the entry being fully available
15287                  before fetching it.  */
15288               if (data
15289                   && data + ent - pltgot + addr_size <= data_end
15290                   && (byte_get (data + ent - pltgot, addr_size)
15291                       >> (addr_size * 8 - 1)) != 0)
15292                 {
15293                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15294                   printf ("\n");
15295                   if (ent == (bfd_vma) -1)
15296                     goto sgot_print_fail;
15297                 }
15298               printf ("\n");
15299             }
15300
15301           if (ent < end)
15302             {
15303               printf (_(" Local entries:\n"));
15304               printf ("  %*s %10s %*s\n",
15305                       addr_size * 2, _("Address"), _("Access"),
15306                       addr_size * 2, _("Value"));
15307               while (ent < end)
15308                 {
15309                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15310                   printf ("\n");
15311                   if (ent == (bfd_vma) -1)
15312                     goto sgot_print_fail;
15313                 }
15314               printf ("\n");
15315             }
15316
15317         sgot_print_fail:
15318           if (data)
15319             free (data);
15320         }
15321       return res;
15322     }
15323
15324   for (entry = dynamic_section;
15325        /* PR 17531 file: 012-50589-0.004.  */
15326        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15327        ++entry)
15328     switch (entry->d_tag)
15329       {
15330       case DT_MIPS_LIBLIST:
15331         liblist_offset
15332           = offset_from_vma (file, entry->d_un.d_val,
15333                              liblistno * sizeof (Elf32_External_Lib));
15334         break;
15335       case DT_MIPS_LIBLISTNO:
15336         liblistno = entry->d_un.d_val;
15337         break;
15338       case DT_MIPS_OPTIONS:
15339         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15340         break;
15341       case DT_MIPS_CONFLICT:
15342         conflicts_offset
15343           = offset_from_vma (file, entry->d_un.d_val,
15344                              conflictsno * sizeof (Elf32_External_Conflict));
15345         break;
15346       case DT_MIPS_CONFLICTNO:
15347         conflictsno = entry->d_un.d_val;
15348         break;
15349       case DT_PLTGOT:
15350         pltgot = entry->d_un.d_ptr;
15351         break;
15352       case DT_MIPS_LOCAL_GOTNO:
15353         local_gotno = entry->d_un.d_val;
15354         break;
15355       case DT_MIPS_GOTSYM:
15356         gotsym = entry->d_un.d_val;
15357         break;
15358       case DT_MIPS_SYMTABNO:
15359         symtabno = entry->d_un.d_val;
15360         break;
15361       case DT_MIPS_PLTGOT:
15362         mips_pltgot = entry->d_un.d_ptr;
15363         break;
15364       case DT_PLTREL:
15365         pltrel = entry->d_un.d_val;
15366         break;
15367       case DT_PLTRELSZ:
15368         pltrelsz = entry->d_un.d_val;
15369         break;
15370       case DT_JMPREL:
15371         jmprel = entry->d_un.d_ptr;
15372         break;
15373       default:
15374         break;
15375       }
15376
15377   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15378     {
15379       Elf32_External_Lib * elib;
15380       size_t cnt;
15381
15382       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15383                                               liblistno,
15384                                               sizeof (Elf32_External_Lib),
15385                                               _("liblist section data"));
15386       if (elib)
15387         {
15388           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15389                   (unsigned long) liblistno);
15390           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15391                  stdout);
15392
15393           for (cnt = 0; cnt < liblistno; ++cnt)
15394             {
15395               Elf32_Lib liblist;
15396               time_t atime;
15397               char timebuf[128];
15398               struct tm * tmp;
15399
15400               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15401               atime = BYTE_GET (elib[cnt].l_time_stamp);
15402               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15403               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15404               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15405
15406               tmp = gmtime (&atime);
15407               snprintf (timebuf, sizeof (timebuf),
15408                         "%04u-%02u-%02uT%02u:%02u:%02u",
15409                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15410                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15411
15412               printf ("%3lu: ", (unsigned long) cnt);
15413               if (VALID_DYNAMIC_NAME (liblist.l_name))
15414                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15415               else
15416                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15417               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15418                       liblist.l_version);
15419
15420               if (liblist.l_flags == 0)
15421                 puts (_(" NONE"));
15422               else
15423                 {
15424                   static const struct
15425                   {
15426                     const char * name;
15427                     int bit;
15428                   }
15429                   l_flags_vals[] =
15430                   {
15431                     { " EXACT_MATCH", LL_EXACT_MATCH },
15432                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15433                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15434                     { " EXPORTS", LL_EXPORTS },
15435                     { " DELAY_LOAD", LL_DELAY_LOAD },
15436                     { " DELTA", LL_DELTA }
15437                   };
15438                   int flags = liblist.l_flags;
15439                   size_t fcnt;
15440
15441                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15442                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15443                       {
15444                         fputs (l_flags_vals[fcnt].name, stdout);
15445                         flags ^= l_flags_vals[fcnt].bit;
15446                       }
15447                   if (flags != 0)
15448                     printf (" %#x", (unsigned int) flags);
15449
15450                   puts ("");
15451                 }
15452             }
15453
15454           free (elib);
15455         }
15456       else
15457         res = FALSE;
15458     }
15459
15460   if (options_offset != 0)
15461     {
15462       Elf_External_Options * eopt;
15463       Elf_Internal_Options * iopt;
15464       Elf_Internal_Options * option;
15465       size_t offset;
15466       int cnt;
15467       sect = section_headers;
15468
15469       /* Find the section header so that we get the size.  */
15470       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15471       /* PR 17533 file: 012-277276-0.004.  */
15472       if (sect == NULL)
15473         {
15474           error (_("No MIPS_OPTIONS header found\n"));
15475           return FALSE;
15476         }
15477
15478       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15479                                                 sect->sh_size, _("options"));
15480       if (eopt)
15481         {
15482           iopt = (Elf_Internal_Options *)
15483               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15484           if (iopt == NULL)
15485             {
15486               error (_("Out of memory allocating space for MIPS options\n"));
15487               return FALSE;
15488             }
15489
15490           offset = cnt = 0;
15491           option = iopt;
15492
15493           while (offset <= sect->sh_size - sizeof (* eopt))
15494             {
15495               Elf_External_Options * eoption;
15496
15497               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15498
15499               option->kind = BYTE_GET (eoption->kind);
15500               option->size = BYTE_GET (eoption->size);
15501               option->section = BYTE_GET (eoption->section);
15502               option->info = BYTE_GET (eoption->info);
15503
15504               /* PR 17531: file: ffa0fa3b.  */
15505               if (option->size < sizeof (* eopt)
15506                   || offset + option->size > sect->sh_size)
15507                 {
15508                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15509                   return FALSE;
15510                 }
15511               offset += option->size;
15512
15513               ++option;
15514               ++cnt;
15515             }
15516
15517           printf (_("\nSection '%s' contains %d entries:\n"),
15518                   printable_section_name (sect), cnt);
15519
15520           option = iopt;
15521           offset = 0;
15522
15523           while (cnt-- > 0)
15524             {
15525               size_t len;
15526
15527               switch (option->kind)
15528                 {
15529                 case ODK_NULL:
15530                   /* This shouldn't happen.  */
15531                   printf (" NULL       %d %lx", option->section, option->info);
15532                   break;
15533                 case ODK_REGINFO:
15534                   printf (" REGINFO    ");
15535                   if (elf_header.e_machine == EM_MIPS)
15536                     {
15537                       /* 32bit form.  */
15538                       Elf32_External_RegInfo * ereg;
15539                       Elf32_RegInfo reginfo;
15540
15541                       ereg = (Elf32_External_RegInfo *) (option + 1);
15542                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15543                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15544                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15545                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15546                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15547                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15548
15549                       printf ("GPR %08lx  GP 0x%lx\n",
15550                               reginfo.ri_gprmask,
15551                               (unsigned long) reginfo.ri_gp_value);
15552                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15553                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15554                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15555                     }
15556                   else
15557                     {
15558                       /* 64 bit form.  */
15559                       Elf64_External_RegInfo * ereg;
15560                       Elf64_Internal_RegInfo reginfo;
15561
15562                       ereg = (Elf64_External_RegInfo *) (option + 1);
15563                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15564                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15565                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15566                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15567                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15568                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15569
15570                       printf ("GPR %08lx  GP 0x",
15571                               reginfo.ri_gprmask);
15572                       printf_vma (reginfo.ri_gp_value);
15573                       printf ("\n");
15574
15575                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15576                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15577                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15578                     }
15579                   ++option;
15580                   continue;
15581                 case ODK_EXCEPTIONS:
15582                   fputs (" EXCEPTIONS fpe_min(", stdout);
15583                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15584                   fputs (") fpe_max(", stdout);
15585                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15586                   fputs (")", stdout);
15587
15588                   if (option->info & OEX_PAGE0)
15589                     fputs (" PAGE0", stdout);
15590                   if (option->info & OEX_SMM)
15591                     fputs (" SMM", stdout);
15592                   if (option->info & OEX_FPDBUG)
15593                     fputs (" FPDBUG", stdout);
15594                   if (option->info & OEX_DISMISS)
15595                     fputs (" DISMISS", stdout);
15596                   break;
15597                 case ODK_PAD:
15598                   fputs (" PAD       ", stdout);
15599                   if (option->info & OPAD_PREFIX)
15600                     fputs (" PREFIX", stdout);
15601                   if (option->info & OPAD_POSTFIX)
15602                     fputs (" POSTFIX", stdout);
15603                   if (option->info & OPAD_SYMBOL)
15604                     fputs (" SYMBOL", stdout);
15605                   break;
15606                 case ODK_HWPATCH:
15607                   fputs (" HWPATCH   ", stdout);
15608                   if (option->info & OHW_R4KEOP)
15609                     fputs (" R4KEOP", stdout);
15610                   if (option->info & OHW_R8KPFETCH)
15611                     fputs (" R8KPFETCH", stdout);
15612                   if (option->info & OHW_R5KEOP)
15613                     fputs (" R5KEOP", stdout);
15614                   if (option->info & OHW_R5KCVTL)
15615                     fputs (" R5KCVTL", stdout);
15616                   break;
15617                 case ODK_FILL:
15618                   fputs (" FILL       ", stdout);
15619                   /* XXX Print content of info word?  */
15620                   break;
15621                 case ODK_TAGS:
15622                   fputs (" TAGS       ", stdout);
15623                   /* XXX Print content of info word?  */
15624                   break;
15625                 case ODK_HWAND:
15626                   fputs (" HWAND     ", stdout);
15627                   if (option->info & OHWA0_R4KEOP_CHECKED)
15628                     fputs (" R4KEOP_CHECKED", stdout);
15629                   if (option->info & OHWA0_R4KEOP_CLEAN)
15630                     fputs (" R4KEOP_CLEAN", stdout);
15631                   break;
15632                 case ODK_HWOR:
15633                   fputs (" HWOR      ", stdout);
15634                   if (option->info & OHWA0_R4KEOP_CHECKED)
15635                     fputs (" R4KEOP_CHECKED", stdout);
15636                   if (option->info & OHWA0_R4KEOP_CLEAN)
15637                     fputs (" R4KEOP_CLEAN", stdout);
15638                   break;
15639                 case ODK_GP_GROUP:
15640                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15641                           option->info & OGP_GROUP,
15642                           (option->info & OGP_SELF) >> 16);
15643                   break;
15644                 case ODK_IDENT:
15645                   printf (" IDENT     %#06lx  self-contained %#06lx",
15646                           option->info & OGP_GROUP,
15647                           (option->info & OGP_SELF) >> 16);
15648                   break;
15649                 default:
15650                   /* This shouldn't happen.  */
15651                   printf (" %3d ???     %d %lx",
15652                           option->kind, option->section, option->info);
15653                   break;
15654                 }
15655
15656               len = sizeof (* eopt);
15657               while (len < option->size)
15658                 {
15659                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15660
15661                   if (ISPRINT (datum))
15662                     printf ("%c", datum);
15663                   else
15664                     printf ("\\%03o", datum);
15665                   len ++;
15666                 }
15667               fputs ("\n", stdout);
15668
15669               offset += option->size;
15670               ++option;
15671             }
15672
15673           free (eopt);
15674         }
15675       else
15676         res = FALSE;
15677     }
15678
15679   if (conflicts_offset != 0 && conflictsno != 0)
15680     {
15681       Elf32_Conflict * iconf;
15682       size_t cnt;
15683
15684       if (dynamic_symbols == NULL)
15685         {
15686           error (_("conflict list found without a dynamic symbol table\n"));
15687           return FALSE;
15688         }
15689
15690       /* PR 21345 - print a slightly more helpful error message
15691          if we are sure that the cmalloc will fail.  */
15692       if (conflictsno * sizeof (* iconf) > current_file_size)
15693         {
15694           error (_("Overlarge number of conflicts detected: %lx\n"),
15695                  (long) conflictsno);
15696           return FALSE;
15697         }
15698
15699       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15700       if (iconf == NULL)
15701         {
15702           error (_("Out of memory allocating space for dynamic conflicts\n"));
15703           return FALSE;
15704         }
15705
15706       if (is_32bit_elf)
15707         {
15708           Elf32_External_Conflict * econf32;
15709
15710           econf32 = (Elf32_External_Conflict *)
15711               get_data (NULL, file, conflicts_offset, conflictsno,
15712                         sizeof (* econf32), _("conflict"));
15713           if (!econf32)
15714             return FALSE;
15715
15716           for (cnt = 0; cnt < conflictsno; ++cnt)
15717             iconf[cnt] = BYTE_GET (econf32[cnt]);
15718
15719           free (econf32);
15720         }
15721       else
15722         {
15723           Elf64_External_Conflict * econf64;
15724
15725           econf64 = (Elf64_External_Conflict *)
15726               get_data (NULL, file, conflicts_offset, conflictsno,
15727                         sizeof (* econf64), _("conflict"));
15728           if (!econf64)
15729             return FALSE;
15730
15731           for (cnt = 0; cnt < conflictsno; ++cnt)
15732             iconf[cnt] = BYTE_GET (econf64[cnt]);
15733
15734           free (econf64);
15735         }
15736
15737       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15738               (unsigned long) conflictsno);
15739       puts (_("  Num:    Index       Value  Name"));
15740
15741       for (cnt = 0; cnt < conflictsno; ++cnt)
15742         {
15743           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15744
15745           if (iconf[cnt] >= num_dynamic_syms)
15746             printf (_("<corrupt symbol index>"));
15747           else
15748             {
15749               Elf_Internal_Sym * psym;
15750
15751               psym = & dynamic_symbols[iconf[cnt]];
15752               print_vma (psym->st_value, FULL_HEX);
15753               putchar (' ');
15754               if (VALID_DYNAMIC_NAME (psym->st_name))
15755                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15756               else
15757                 printf (_("<corrupt: %14ld>"), psym->st_name);
15758             }
15759           putchar ('\n');
15760         }
15761
15762       free (iconf);
15763     }
15764
15765   if (pltgot != 0 && local_gotno != 0)
15766     {
15767       bfd_vma ent, local_end, global_end;
15768       size_t i, offset;
15769       unsigned char * data;
15770       unsigned char * data_end;
15771       int addr_size;
15772
15773       ent = pltgot;
15774       addr_size = (is_32bit_elf ? 4 : 8);
15775       local_end = pltgot + local_gotno * addr_size;
15776
15777       /* PR binutils/17533 file: 012-111227-0.004  */
15778       if (symtabno < gotsym)
15779         {
15780           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15781                  (unsigned long) gotsym, (unsigned long) symtabno);
15782           return FALSE;
15783         }
15784
15785       global_end = local_end + (symtabno - gotsym) * addr_size;
15786       /* PR 17531: file: 54c91a34.  */
15787       if (global_end < local_end)
15788         {
15789           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15790           return FALSE;
15791         }
15792
15793       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15794       data = (unsigned char *) get_data (NULL, file, offset,
15795                                          global_end - pltgot, 1,
15796                                          _("Global Offset Table data"));
15797       /* PR 12855: Null data is handled gracefully throughout.  */
15798       data_end = data + (global_end - pltgot);
15799
15800       printf (_("\nPrimary GOT:\n"));
15801       printf (_(" Canonical gp value: "));
15802       print_vma (pltgot + 0x7ff0, LONG_HEX);
15803       printf ("\n\n");
15804
15805       printf (_(" Reserved entries:\n"));
15806       printf (_("  %*s %10s %*s Purpose\n"),
15807               addr_size * 2, _("Address"), _("Access"),
15808               addr_size * 2, _("Initial"));
15809       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15810       printf (_(" Lazy resolver\n"));
15811       if (ent == (bfd_vma) -1)
15812         goto got_print_fail;
15813
15814       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15815          This entry will be used by some runtime loaders, to store the
15816          module pointer.  Otherwise this is an ordinary local entry.
15817          PR 21344: Check for the entry being fully available before
15818          fetching it.  */
15819       if (data
15820           && data + ent - pltgot + addr_size <= data_end
15821           && (byte_get (data + ent - pltgot, addr_size)
15822               >> (addr_size * 8 - 1)) != 0)
15823         {
15824           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15825           printf (_(" Module pointer (GNU extension)\n"));
15826           if (ent == (bfd_vma) -1)
15827             goto got_print_fail;
15828         }
15829       printf ("\n");
15830
15831       if (ent < local_end)
15832         {
15833           printf (_(" Local entries:\n"));
15834           printf ("  %*s %10s %*s\n",
15835                   addr_size * 2, _("Address"), _("Access"),
15836                   addr_size * 2, _("Initial"));
15837           while (ent < local_end)
15838             {
15839               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15840               printf ("\n");
15841               if (ent == (bfd_vma) -1)
15842                 goto got_print_fail;
15843             }
15844           printf ("\n");
15845         }
15846
15847       if (gotsym < symtabno)
15848         {
15849           int sym_width;
15850
15851           printf (_(" Global entries:\n"));
15852           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15853                   addr_size * 2, _("Address"),
15854                   _("Access"),
15855                   addr_size * 2, _("Initial"),
15856                   addr_size * 2, _("Sym.Val."),
15857                   _("Type"),
15858                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15859                   _("Ndx"), _("Name"));
15860
15861           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15862
15863           for (i = gotsym; i < symtabno; i++)
15864             {
15865               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15866               printf (" ");
15867
15868               if (dynamic_symbols == NULL)
15869                 printf (_("<no dynamic symbols>"));
15870               else if (i < num_dynamic_syms)
15871                 {
15872                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15873
15874                   print_vma (psym->st_value, LONG_HEX);
15875                   printf (" %-7s %3s ",
15876                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15877                           get_symbol_index_type (psym->st_shndx));
15878
15879                   if (VALID_DYNAMIC_NAME (psym->st_name))
15880                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15881                   else
15882                     printf (_("<corrupt: %14ld>"), psym->st_name);
15883                 }
15884               else
15885                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15886                         (unsigned long) i);
15887
15888               printf ("\n");
15889               if (ent == (bfd_vma) -1)
15890                 break;
15891             }
15892           printf ("\n");
15893         }
15894
15895     got_print_fail:
15896       if (data)
15897         free (data);
15898     }
15899
15900   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15901     {
15902       bfd_vma ent, end;
15903       size_t offset, rel_offset;
15904       unsigned long count, i;
15905       unsigned char * data;
15906       int addr_size, sym_width;
15907       Elf_Internal_Rela * rels;
15908
15909       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15910       if (pltrel == DT_RELA)
15911         {
15912           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15913             return FALSE;
15914         }
15915       else
15916         {
15917           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15918             return FALSE;
15919         }
15920
15921       ent = mips_pltgot;
15922       addr_size = (is_32bit_elf ? 4 : 8);
15923       end = mips_pltgot + (2 + count) * addr_size;
15924
15925       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15926       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15927                                          1, _("Procedure Linkage Table data"));
15928       if (data == NULL)
15929         return FALSE;
15930
15931       printf ("\nPLT GOT:\n\n");
15932       printf (_(" Reserved entries:\n"));
15933       printf (_("  %*s %*s Purpose\n"),
15934               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15935       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15936       printf (_(" PLT lazy resolver\n"));
15937       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15938       printf (_(" Module pointer\n"));
15939       printf ("\n");
15940
15941       printf (_(" Entries:\n"));
15942       printf ("  %*s %*s %*s %-7s %3s %s\n",
15943               addr_size * 2, _("Address"),
15944               addr_size * 2, _("Initial"),
15945               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15946       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15947       for (i = 0; i < count; i++)
15948         {
15949           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15950
15951           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15952           printf (" ");
15953
15954           if (idx >= num_dynamic_syms)
15955             printf (_("<corrupt symbol index: %lu>"), idx);
15956           else
15957             {
15958               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15959
15960               print_vma (psym->st_value, LONG_HEX);
15961               printf (" %-7s %3s ",
15962                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15963                       get_symbol_index_type (psym->st_shndx));
15964               if (VALID_DYNAMIC_NAME (psym->st_name))
15965                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15966               else
15967                 printf (_("<corrupt: %14ld>"), psym->st_name);
15968             }
15969           printf ("\n");
15970         }
15971       printf ("\n");
15972
15973       if (data)
15974         free (data);
15975       free (rels);
15976     }
15977
15978   return res;
15979 }
15980
15981 static bfd_boolean
15982 process_nds32_specific (FILE * file)
15983 {
15984   Elf_Internal_Shdr *sect = NULL;
15985
15986   sect = find_section (".nds32_e_flags");
15987   if (sect != NULL)
15988     {
15989       unsigned int *flag;
15990
15991       printf ("\nNDS32 elf flags section:\n");
15992       flag = get_data (NULL, file, sect->sh_offset, 1,
15993                        sect->sh_size, _("NDS32 elf flags section"));
15994
15995       if (! flag)
15996         return FALSE;
15997
15998       switch ((*flag) & 0x3)
15999         {
16000         case 0:
16001           printf ("(VEC_SIZE):\tNo entry.\n");
16002           break;
16003         case 1:
16004           printf ("(VEC_SIZE):\t4 bytes\n");
16005           break;
16006         case 2:
16007           printf ("(VEC_SIZE):\t16 bytes\n");
16008           break;
16009         case 3:
16010           printf ("(VEC_SIZE):\treserved\n");
16011           break;
16012         }
16013     }
16014
16015   return TRUE;
16016 }
16017
16018 static bfd_boolean
16019 process_gnu_liblist (FILE * file)
16020 {
16021   Elf_Internal_Shdr * section;
16022   Elf_Internal_Shdr * string_sec;
16023   Elf32_External_Lib * elib;
16024   char * strtab;
16025   size_t strtab_size;
16026   size_t cnt;
16027   unsigned i;
16028   bfd_boolean res = TRUE;
16029
16030   if (! do_arch)
16031     return TRUE;
16032
16033   for (i = 0, section = section_headers;
16034        i < elf_header.e_shnum;
16035        i++, section++)
16036     {
16037       switch (section->sh_type)
16038         {
16039         case SHT_GNU_LIBLIST:
16040           if (section->sh_link >= elf_header.e_shnum)
16041             break;
16042
16043           elib = (Elf32_External_Lib *)
16044               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16045                         _("liblist section data"));
16046
16047           if (elib == NULL)
16048             {
16049               res = FALSE;
16050               break;
16051             }
16052
16053           string_sec = section_headers + section->sh_link;
16054           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16055                                       string_sec->sh_size,
16056                                       _("liblist string table"));
16057           if (strtab == NULL
16058               || section->sh_entsize != sizeof (Elf32_External_Lib))
16059             {
16060               free (elib);
16061               free (strtab);
16062               res = FALSE;
16063               break;
16064             }
16065           strtab_size = string_sec->sh_size;
16066
16067           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16068                   printable_section_name (section),
16069                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16070
16071           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16072
16073           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16074                ++cnt)
16075             {
16076               Elf32_Lib liblist;
16077               time_t atime;
16078               char timebuf[128];
16079               struct tm * tmp;
16080
16081               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16082               atime = BYTE_GET (elib[cnt].l_time_stamp);
16083               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16084               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16085               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16086
16087               tmp = gmtime (&atime);
16088               snprintf (timebuf, sizeof (timebuf),
16089                         "%04u-%02u-%02uT%02u:%02u:%02u",
16090                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16091                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16092
16093               printf ("%3lu: ", (unsigned long) cnt);
16094               if (do_wide)
16095                 printf ("%-20s", liblist.l_name < strtab_size
16096                         ? strtab + liblist.l_name : _("<corrupt>"));
16097               else
16098                 printf ("%-20.20s", liblist.l_name < strtab_size
16099                         ? strtab + liblist.l_name : _("<corrupt>"));
16100               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16101                       liblist.l_version, liblist.l_flags);
16102             }
16103
16104           free (elib);
16105           free (strtab);
16106         }
16107     }
16108
16109   return res;
16110 }
16111
16112 static const char *
16113 get_note_type (unsigned e_type)
16114 {
16115   static char buff[64];
16116
16117   if (elf_header.e_type == ET_CORE)
16118     switch (e_type)
16119       {
16120       case NT_AUXV:
16121         return _("NT_AUXV (auxiliary vector)");
16122       case NT_PRSTATUS:
16123         return _("NT_PRSTATUS (prstatus structure)");
16124       case NT_FPREGSET:
16125         return _("NT_FPREGSET (floating point registers)");
16126       case NT_PRPSINFO:
16127         return _("NT_PRPSINFO (prpsinfo structure)");
16128       case NT_TASKSTRUCT:
16129         return _("NT_TASKSTRUCT (task structure)");
16130       case NT_PRXFPREG:
16131         return _("NT_PRXFPREG (user_xfpregs structure)");
16132       case NT_PPC_VMX:
16133         return _("NT_PPC_VMX (ppc Altivec registers)");
16134       case NT_PPC_VSX:
16135         return _("NT_PPC_VSX (ppc VSX registers)");
16136       case NT_PPC_TAR:
16137         return _("NT_PPC_TAR (ppc TAR register)");
16138       case NT_PPC_PPR:
16139         return _("NT_PPC_PPR (ppc PPR register)");
16140       case NT_PPC_DSCR:
16141         return _("NT_PPC_DSCR (ppc DSCR register)");
16142       case NT_PPC_EBB:
16143         return _("NT_PPC_EBB (ppc EBB registers)");
16144       case NT_PPC_PMU:
16145         return _("NT_PPC_PMU (ppc PMU registers)");
16146       case NT_PPC_TM_CGPR:
16147         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16148       case NT_PPC_TM_CFPR:
16149         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16150       case NT_PPC_TM_CVMX:
16151         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16152       case NT_PPC_TM_CVSX:
16153         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16154       case NT_PPC_TM_SPR:
16155         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16156       case NT_PPC_TM_CTAR:
16157         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16158       case NT_PPC_TM_CPPR:
16159         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16160       case NT_PPC_TM_CDSCR:
16161         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16162       case NT_386_TLS:
16163         return _("NT_386_TLS (x86 TLS information)");
16164       case NT_386_IOPERM:
16165         return _("NT_386_IOPERM (x86 I/O permissions)");
16166       case NT_X86_XSTATE:
16167         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16168       case NT_S390_HIGH_GPRS:
16169         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16170       case NT_S390_TIMER:
16171         return _("NT_S390_TIMER (s390 timer register)");
16172       case NT_S390_TODCMP:
16173         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16174       case NT_S390_TODPREG:
16175         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16176       case NT_S390_CTRS:
16177         return _("NT_S390_CTRS (s390 control registers)");
16178       case NT_S390_PREFIX:
16179         return _("NT_S390_PREFIX (s390 prefix register)");
16180       case NT_S390_LAST_BREAK:
16181         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16182       case NT_S390_SYSTEM_CALL:
16183         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16184       case NT_S390_TDB:
16185         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16186       case NT_S390_VXRS_LOW:
16187         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16188       case NT_S390_VXRS_HIGH:
16189         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16190       case NT_S390_GS_CB:
16191         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16192       case NT_S390_GS_BC:
16193         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16194       case NT_ARM_VFP:
16195         return _("NT_ARM_VFP (arm VFP registers)");
16196       case NT_ARM_TLS:
16197         return _("NT_ARM_TLS (AArch TLS registers)");
16198       case NT_ARM_HW_BREAK:
16199         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16200       case NT_ARM_HW_WATCH:
16201         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16202       case NT_PSTATUS:
16203         return _("NT_PSTATUS (pstatus structure)");
16204       case NT_FPREGS:
16205         return _("NT_FPREGS (floating point registers)");
16206       case NT_PSINFO:
16207         return _("NT_PSINFO (psinfo structure)");
16208       case NT_LWPSTATUS:
16209         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16210       case NT_LWPSINFO:
16211         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16212       case NT_WIN32PSTATUS:
16213         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16214       case NT_SIGINFO:
16215         return _("NT_SIGINFO (siginfo_t data)");
16216       case NT_FILE:
16217         return _("NT_FILE (mapped files)");
16218       default:
16219         break;
16220       }
16221   else
16222     switch (e_type)
16223       {
16224       case NT_VERSION:
16225         return _("NT_VERSION (version)");
16226       case NT_ARCH:
16227         return _("NT_ARCH (architecture)");
16228       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16229         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16230       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16231         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16232       default:
16233         break;
16234       }
16235
16236   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16237   return buff;
16238 }
16239
16240 static bfd_boolean
16241 print_core_note (Elf_Internal_Note *pnote)
16242 {
16243   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16244   bfd_vma count, page_size;
16245   unsigned char *descdata, *filenames, *descend;
16246
16247   if (pnote->type != NT_FILE)
16248     {
16249       if (do_wide)
16250         printf ("\n");
16251       return TRUE;
16252     }
16253
16254 #ifndef BFD64
16255   if (!is_32bit_elf)
16256     {
16257       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16258       /* Still "successful".  */
16259       return TRUE;
16260     }
16261 #endif
16262
16263   if (pnote->descsz < 2 * addr_size)
16264     {
16265       error (_("    Malformed note - too short for header\n"));
16266       return FALSE;
16267     }
16268
16269   descdata = (unsigned char *) pnote->descdata;
16270   descend = descdata + pnote->descsz;
16271
16272   if (descdata[pnote->descsz - 1] != '\0')
16273     {
16274       error (_("    Malformed note - does not end with \\0\n"));
16275       return FALSE;
16276     }
16277
16278   count = byte_get (descdata, addr_size);
16279   descdata += addr_size;
16280
16281   page_size = byte_get (descdata, addr_size);
16282   descdata += addr_size;
16283
16284   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16285     {
16286       error (_("    Malformed note - too short for supplied file count\n"));
16287       return FALSE;
16288     }
16289
16290   printf (_("    Page size: "));
16291   print_vma (page_size, DEC);
16292   printf ("\n");
16293
16294   printf (_("    %*s%*s%*s\n"),
16295           (int) (2 + 2 * addr_size), _("Start"),
16296           (int) (4 + 2 * addr_size), _("End"),
16297           (int) (4 + 2 * addr_size), _("Page Offset"));
16298   filenames = descdata + count * 3 * addr_size;
16299   while (count-- > 0)
16300     {
16301       bfd_vma start, end, file_ofs;
16302
16303       if (filenames == descend)
16304         {
16305           error (_("    Malformed note - filenames end too early\n"));
16306           return FALSE;
16307         }
16308
16309       start = byte_get (descdata, addr_size);
16310       descdata += addr_size;
16311       end = byte_get (descdata, addr_size);
16312       descdata += addr_size;
16313       file_ofs = byte_get (descdata, addr_size);
16314       descdata += addr_size;
16315
16316       printf ("    ");
16317       print_vma (start, FULL_HEX);
16318       printf ("  ");
16319       print_vma (end, FULL_HEX);
16320       printf ("  ");
16321       print_vma (file_ofs, FULL_HEX);
16322       printf ("\n        %s\n", filenames);
16323
16324       filenames += 1 + strlen ((char *) filenames);
16325     }
16326
16327   return TRUE;
16328 }
16329
16330 static const char *
16331 get_gnu_elf_note_type (unsigned e_type)
16332 {
16333   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16334   switch (e_type)
16335     {
16336     case NT_GNU_ABI_TAG:
16337       return _("NT_GNU_ABI_TAG (ABI version tag)");
16338     case NT_GNU_HWCAP:
16339       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16340     case NT_GNU_BUILD_ID:
16341       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16342     case NT_GNU_GOLD_VERSION:
16343       return _("NT_GNU_GOLD_VERSION (gold version)");
16344     case NT_GNU_PROPERTY_TYPE_0:
16345       return _("NT_GNU_PROPERTY_TYPE_0");
16346     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16347       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16348     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16349       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16350     default:
16351       {
16352         static char buff[64];
16353
16354         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16355         return buff;
16356       }
16357     }
16358 }
16359
16360 static void
16361 decode_x86_isa (unsigned int bitmask)
16362 {
16363   while (bitmask)
16364     {
16365       unsigned int bit = bitmask & (- bitmask);
16366
16367       bitmask &= ~ bit;
16368       switch (bit)
16369         {
16370         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16371         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16372         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16373         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16374         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16375         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16376         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16377         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16378         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16379         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16380         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16381         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16382         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16383         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16384         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16385         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16386         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16387         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16388         default: printf (_("<unknown: %x>"), bit); break;
16389         }
16390       if (bitmask)
16391         printf (", ");
16392     }
16393 }
16394
16395 static void
16396 decode_x86_feature (unsigned int type, unsigned int bitmask)
16397 {
16398   while (bitmask)
16399     {
16400       unsigned int bit = bitmask & (- bitmask);
16401
16402       bitmask &= ~ bit;
16403       switch (bit)
16404         {
16405         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16406           switch (type)
16407             {
16408             case GNU_PROPERTY_X86_FEATURE_1_AND:
16409               printf ("IBT");
16410               break;
16411             default:
16412               /* This should never happen.  */
16413               abort ();
16414             }
16415           break;
16416         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16417           switch (type)
16418             {
16419             case GNU_PROPERTY_X86_FEATURE_1_AND:
16420               printf ("SHSTK");
16421               break;
16422             default:
16423               /* This should never happen.  */
16424               abort ();
16425             }
16426           break;
16427         default:
16428           printf (_("<unknown: %x>"), bit);
16429           break;
16430         }
16431       if (bitmask)
16432         printf (", ");
16433     }
16434 }
16435
16436 static void
16437 print_gnu_property_note (Elf_Internal_Note * pnote)
16438 {
16439   unsigned char * ptr = (unsigned char *) pnote->descdata;
16440   unsigned char * ptr_end = ptr + pnote->descsz;
16441   unsigned int    size = is_32bit_elf ? 4 : 8;
16442
16443   printf (_("      Properties: "));
16444
16445   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16446     {
16447       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16448       return;
16449     }
16450
16451   while (1)
16452     {
16453       unsigned int j;
16454       unsigned int type = byte_get (ptr, 4);
16455       unsigned int datasz = byte_get (ptr + 4, 4);
16456
16457       ptr += 8;
16458
16459       if ((ptr + datasz) > ptr_end)
16460         {
16461           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16462                   type, datasz);
16463           break;
16464         }
16465
16466       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16467         {
16468           if (elf_header.e_machine == EM_X86_64
16469               || elf_header.e_machine == EM_IAMCU
16470               || elf_header.e_machine == EM_386)
16471             {
16472               switch (type)
16473                 {
16474                 case GNU_PROPERTY_X86_ISA_1_USED:
16475                   printf ("x86 ISA used: ");
16476                   if (datasz != 4)
16477                     printf (_("<corrupt length: %#x> "), datasz);
16478                   else
16479                     decode_x86_isa (byte_get (ptr, 4));
16480                   goto next;
16481
16482                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16483                   printf ("x86 ISA needed: ");
16484                   if (datasz != 4)
16485                     printf (_("<corrupt length: %#x> "), datasz);
16486                   else
16487                     decode_x86_isa (byte_get (ptr, 4));
16488                   goto next;
16489
16490                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16491                   printf ("x86 feature: ");
16492                   if (datasz != 4)
16493                     printf (_("<corrupt length: %#x> "), datasz);
16494                   else
16495                     decode_x86_feature (type, byte_get (ptr, 4));
16496                   goto next;
16497
16498                 default:
16499                   break;
16500                 }
16501             }
16502         }
16503       else
16504         {
16505           switch (type)
16506             {
16507             case GNU_PROPERTY_STACK_SIZE:
16508               printf (_("stack size: "));
16509               if (datasz != size)
16510                 printf (_("<corrupt length: %#x> "), datasz);
16511               else
16512                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16513               goto next;
16514
16515             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16516               printf ("no copy on protected ");
16517               if (datasz)
16518                 printf (_("<corrupt length: %#x> "), datasz);
16519               goto next;
16520
16521             default:
16522               break;
16523             }
16524         }
16525
16526       if (type < GNU_PROPERTY_LOPROC)
16527         printf (_("<unknown type %#x data: "), type);
16528       else if (type < GNU_PROPERTY_LOUSER)
16529         printf (_("<procesor-specific type %#x data: "), type);
16530       else
16531         printf (_("<application-specific type %#x data: "), type);
16532       for (j = 0; j < datasz; ++j)
16533         printf ("%02x ", ptr[j] & 0xff);
16534       printf (">");
16535
16536 next:
16537       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16538       if (ptr == ptr_end)
16539         break;
16540       else
16541         {
16542           if (do_wide)
16543             printf (", ");
16544           else
16545             printf ("\n\t");
16546         }
16547
16548       if (ptr > (ptr_end - 8))
16549         {
16550           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16551           break;
16552         }
16553     }
16554
16555   printf ("\n");
16556 }
16557
16558 static bfd_boolean
16559 print_gnu_note (Elf_Internal_Note *pnote)
16560 {
16561   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16562   switch (pnote->type)
16563     {
16564     case NT_GNU_BUILD_ID:
16565       {
16566         unsigned long i;
16567
16568         printf (_("    Build ID: "));
16569         for (i = 0; i < pnote->descsz; ++i)
16570           printf ("%02x", pnote->descdata[i] & 0xff);
16571         printf ("\n");
16572       }
16573       break;
16574
16575     case NT_GNU_ABI_TAG:
16576       {
16577         unsigned long os, major, minor, subminor;
16578         const char *osname;
16579
16580         /* PR 17531: file: 030-599401-0.004.  */
16581         if (pnote->descsz < 16)
16582           {
16583             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16584             break;
16585           }
16586
16587         os = byte_get ((unsigned char *) pnote->descdata, 4);
16588         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16589         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16590         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16591
16592         switch (os)
16593           {
16594           case GNU_ABI_TAG_LINUX:
16595             osname = "Linux";
16596             break;
16597           case GNU_ABI_TAG_HURD:
16598             osname = "Hurd";
16599             break;
16600           case GNU_ABI_TAG_SOLARIS:
16601             osname = "Solaris";
16602             break;
16603           case GNU_ABI_TAG_FREEBSD:
16604             osname = "FreeBSD";
16605             break;
16606           case GNU_ABI_TAG_NETBSD:
16607             osname = "NetBSD";
16608             break;
16609           case GNU_ABI_TAG_SYLLABLE:
16610             osname = "Syllable";
16611             break;
16612           case GNU_ABI_TAG_NACL:
16613             osname = "NaCl";
16614             break;
16615           default:
16616             osname = "Unknown";
16617             break;
16618           }
16619
16620         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16621                 major, minor, subminor);
16622       }
16623       break;
16624
16625     case NT_GNU_GOLD_VERSION:
16626       {
16627         unsigned long i;
16628
16629         printf (_("    Version: "));
16630         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16631           printf ("%c", pnote->descdata[i]);
16632         printf ("\n");
16633       }
16634       break;
16635
16636     case NT_GNU_HWCAP:
16637       {
16638         unsigned long num_entries, mask;
16639
16640         /* Hardware capabilities information.  Word 0 is the number of entries.
16641            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16642            is a series of entries, where each entry is a single byte followed
16643            by a nul terminated string.  The byte gives the bit number to test
16644            if enabled in the bitmask.  */
16645         printf (_("      Hardware Capabilities: "));
16646         if (pnote->descsz < 8)
16647           {
16648             error (_("<corrupt GNU_HWCAP>\n"));
16649             return FALSE;
16650           }
16651         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16652         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16653         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16654         /* FIXME: Add code to display the entries... */
16655       }
16656       break;
16657
16658     case NT_GNU_PROPERTY_TYPE_0:
16659       print_gnu_property_note (pnote);
16660       break;
16661
16662     default:
16663       /* Handle unrecognised types.  An error message should have already been
16664          created by get_gnu_elf_note_type(), so all that we need to do is to
16665          display the data.  */
16666       {
16667         unsigned long i;
16668
16669         printf (_("    Description data: "));
16670         for (i = 0; i < pnote->descsz; ++i)
16671           printf ("%02x ", pnote->descdata[i] & 0xff);
16672         printf ("\n");
16673       }
16674       break;
16675     }
16676
16677   return TRUE;
16678 }
16679
16680 static const char *
16681 get_v850_elf_note_type (enum v850_notes n_type)
16682 {
16683   static char buff[64];
16684
16685   switch (n_type)
16686     {
16687     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16688     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16689     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16690     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16691     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16692     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16693     default:
16694       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16695       return buff;
16696     }
16697 }
16698
16699 static bfd_boolean
16700 print_v850_note (Elf_Internal_Note * pnote)
16701 {
16702   unsigned int val;
16703
16704   if (pnote->descsz != 4)
16705     return FALSE;
16706
16707   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16708
16709   if (val == 0)
16710     {
16711       printf (_("not set\n"));
16712       return TRUE;
16713     }
16714
16715   switch (pnote->type)
16716     {
16717     case V850_NOTE_ALIGNMENT:
16718       switch (val)
16719         {
16720         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16721         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16722         }
16723       break;
16724
16725     case V850_NOTE_DATA_SIZE:
16726       switch (val)
16727         {
16728         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16729         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16730         }
16731       break;
16732
16733     case V850_NOTE_FPU_INFO:
16734       switch (val)
16735         {
16736         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16737         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16738         }
16739       break;
16740
16741     case V850_NOTE_MMU_INFO:
16742     case V850_NOTE_CACHE_INFO:
16743     case V850_NOTE_SIMD_INFO:
16744       if (val == EF_RH850_SIMD)
16745         {
16746           printf (_("yes\n"));
16747           return TRUE;
16748         }
16749       break;
16750
16751     default:
16752       /* An 'unknown note type' message will already have been displayed.  */
16753       break;
16754     }
16755
16756   printf (_("unknown value: %x\n"), val);
16757   return FALSE;
16758 }
16759
16760 static bfd_boolean
16761 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16762 {
16763   unsigned int version;
16764
16765   switch (pnote->type)
16766     {
16767     case NT_NETBSD_IDENT:
16768       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16769       if ((version / 10000) % 100)
16770         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16771                 version, version / 100000000, (version / 1000000) % 100,
16772                 (version / 10000) % 100 > 26 ? "Z" : "",
16773                 'A' + (version / 10000) % 26);
16774       else
16775         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16776                 version, version / 100000000, (version / 1000000) % 100,
16777                 (version / 100) % 100);
16778       return TRUE;
16779
16780     case NT_NETBSD_MARCH:
16781       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16782               pnote->descdata);
16783       return TRUE;
16784
16785     default:
16786       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16787               pnote->type);
16788       return FALSE;
16789     }
16790 }
16791
16792 static const char *
16793 get_freebsd_elfcore_note_type (unsigned e_type)
16794 {
16795   switch (e_type)
16796     {
16797     case NT_FREEBSD_THRMISC:
16798       return _("NT_THRMISC (thrmisc structure)");
16799     case NT_FREEBSD_PROCSTAT_PROC:
16800       return _("NT_PROCSTAT_PROC (proc data)");
16801     case NT_FREEBSD_PROCSTAT_FILES:
16802       return _("NT_PROCSTAT_FILES (files data)");
16803     case NT_FREEBSD_PROCSTAT_VMMAP:
16804       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16805     case NT_FREEBSD_PROCSTAT_GROUPS:
16806       return _("NT_PROCSTAT_GROUPS (groups data)");
16807     case NT_FREEBSD_PROCSTAT_UMASK:
16808       return _("NT_PROCSTAT_UMASK (umask data)");
16809     case NT_FREEBSD_PROCSTAT_RLIMIT:
16810       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16811     case NT_FREEBSD_PROCSTAT_OSREL:
16812       return _("NT_PROCSTAT_OSREL (osreldate data)");
16813     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16814       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16815     case NT_FREEBSD_PROCSTAT_AUXV:
16816       return _("NT_PROCSTAT_AUXV (auxv data)");
16817     case NT_FREEBSD_PTLWPINFO:
16818       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16819     }
16820   return get_note_type (e_type);
16821 }
16822
16823 static const char *
16824 get_netbsd_elfcore_note_type (unsigned e_type)
16825 {
16826   static char buff[64];
16827
16828   if (e_type == NT_NETBSDCORE_PROCINFO)
16829     {
16830       /* NetBSD core "procinfo" structure.  */
16831       return _("NetBSD procinfo structure");
16832     }
16833
16834   /* As of Jan 2002 there are no other machine-independent notes
16835      defined for NetBSD core files.  If the note type is less
16836      than the start of the machine-dependent note types, we don't
16837      understand it.  */
16838
16839   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16840     {
16841       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16842       return buff;
16843     }
16844
16845   switch (elf_header.e_machine)
16846     {
16847     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16848        and PT_GETFPREGS == mach+2.  */
16849
16850     case EM_OLD_ALPHA:
16851     case EM_ALPHA:
16852     case EM_SPARC:
16853     case EM_SPARC32PLUS:
16854     case EM_SPARCV9:
16855       switch (e_type)
16856         {
16857         case NT_NETBSDCORE_FIRSTMACH + 0:
16858           return _("PT_GETREGS (reg structure)");
16859         case NT_NETBSDCORE_FIRSTMACH + 2:
16860           return _("PT_GETFPREGS (fpreg structure)");
16861         default:
16862           break;
16863         }
16864       break;
16865
16866     /* On all other arch's, PT_GETREGS == mach+1 and
16867        PT_GETFPREGS == mach+3.  */
16868     default:
16869       switch (e_type)
16870         {
16871         case NT_NETBSDCORE_FIRSTMACH + 1:
16872           return _("PT_GETREGS (reg structure)");
16873         case NT_NETBSDCORE_FIRSTMACH + 3:
16874           return _("PT_GETFPREGS (fpreg structure)");
16875         default:
16876           break;
16877         }
16878     }
16879
16880   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16881             e_type - NT_NETBSDCORE_FIRSTMACH);
16882   return buff;
16883 }
16884
16885 static const char *
16886 get_stapsdt_note_type (unsigned e_type)
16887 {
16888   static char buff[64];
16889
16890   switch (e_type)
16891     {
16892     case NT_STAPSDT:
16893       return _("NT_STAPSDT (SystemTap probe descriptors)");
16894
16895     default:
16896       break;
16897     }
16898
16899   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16900   return buff;
16901 }
16902
16903 static bfd_boolean
16904 print_stapsdt_note (Elf_Internal_Note *pnote)
16905 {
16906   int addr_size = is_32bit_elf ? 4 : 8;
16907   char *data = pnote->descdata;
16908   char *data_end = pnote->descdata + pnote->descsz;
16909   bfd_vma pc, base_addr, semaphore;
16910   char *provider, *probe, *arg_fmt;
16911
16912   pc = byte_get ((unsigned char *) data, addr_size);
16913   data += addr_size;
16914   base_addr = byte_get ((unsigned char *) data, addr_size);
16915   data += addr_size;
16916   semaphore = byte_get ((unsigned char *) data, addr_size);
16917   data += addr_size;
16918
16919   provider = data;
16920   data += strlen (data) + 1;
16921   probe = data;
16922   data += strlen (data) + 1;
16923   arg_fmt = data;
16924   data += strlen (data) + 1;
16925
16926   printf (_("    Provider: %s\n"), provider);
16927   printf (_("    Name: %s\n"), probe);
16928   printf (_("    Location: "));
16929   print_vma (pc, FULL_HEX);
16930   printf (_(", Base: "));
16931   print_vma (base_addr, FULL_HEX);
16932   printf (_(", Semaphore: "));
16933   print_vma (semaphore, FULL_HEX);
16934   printf ("\n");
16935   printf (_("    Arguments: %s\n"), arg_fmt);
16936
16937   return data == data_end;
16938 }
16939
16940 static const char *
16941 get_ia64_vms_note_type (unsigned e_type)
16942 {
16943   static char buff[64];
16944
16945   switch (e_type)
16946     {
16947     case NT_VMS_MHD:
16948       return _("NT_VMS_MHD (module header)");
16949     case NT_VMS_LNM:
16950       return _("NT_VMS_LNM (language name)");
16951     case NT_VMS_SRC:
16952       return _("NT_VMS_SRC (source files)");
16953     case NT_VMS_TITLE:
16954       return "NT_VMS_TITLE";
16955     case NT_VMS_EIDC:
16956       return _("NT_VMS_EIDC (consistency check)");
16957     case NT_VMS_FPMODE:
16958       return _("NT_VMS_FPMODE (FP mode)");
16959     case NT_VMS_LINKTIME:
16960       return "NT_VMS_LINKTIME";
16961     case NT_VMS_IMGNAM:
16962       return _("NT_VMS_IMGNAM (image name)");
16963     case NT_VMS_IMGID:
16964       return _("NT_VMS_IMGID (image id)");
16965     case NT_VMS_LINKID:
16966       return _("NT_VMS_LINKID (link id)");
16967     case NT_VMS_IMGBID:
16968       return _("NT_VMS_IMGBID (build id)");
16969     case NT_VMS_GSTNAM:
16970       return _("NT_VMS_GSTNAM (sym table name)");
16971     case NT_VMS_ORIG_DYN:
16972       return "NT_VMS_ORIG_DYN";
16973     case NT_VMS_PATCHTIME:
16974       return "NT_VMS_PATCHTIME";
16975     default:
16976       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16977       return buff;
16978     }
16979 }
16980
16981 static bfd_boolean
16982 print_ia64_vms_note (Elf_Internal_Note * pnote)
16983 {
16984   switch (pnote->type)
16985     {
16986     case NT_VMS_MHD:
16987       if (pnote->descsz > 36)
16988         {
16989           size_t l = strlen (pnote->descdata + 34);
16990           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16991           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16992           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16993           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16994         }
16995       else
16996         printf (_("    Invalid size\n"));
16997       break;
16998     case NT_VMS_LNM:
16999       printf (_("   Language: %s\n"), pnote->descdata);
17000       break;
17001 #ifdef BFD64
17002     case NT_VMS_FPMODE:
17003       printf (_("   Floating Point mode: "));
17004       printf ("0x%016" BFD_VMA_FMT "x\n",
17005               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17006       break;
17007     case NT_VMS_LINKTIME:
17008       printf (_("   Link time: "));
17009       print_vms_time
17010         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17011       printf ("\n");
17012       break;
17013     case NT_VMS_PATCHTIME:
17014       printf (_("   Patch time: "));
17015       print_vms_time
17016         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17017       printf ("\n");
17018       break;
17019     case NT_VMS_ORIG_DYN:
17020       printf (_("   Major id: %u,  minor id: %u\n"),
17021               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17022               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17023       printf (_("   Last modified  : "));
17024       print_vms_time
17025         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17026       printf (_("\n   Link flags  : "));
17027       printf ("0x%016" BFD_VMA_FMT "x\n",
17028               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17029       printf (_("   Header flags: 0x%08x\n"),
17030               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17031       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17032       break;
17033 #endif
17034     case NT_VMS_IMGNAM:
17035       printf (_("    Image name: %s\n"), pnote->descdata);
17036       break;
17037     case NT_VMS_GSTNAM:
17038       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17039       break;
17040     case NT_VMS_IMGID:
17041       printf (_("    Image id: %s\n"), pnote->descdata);
17042       break;
17043     case NT_VMS_LINKID:
17044       printf (_("    Linker id: %s\n"), pnote->descdata);
17045       break;
17046     default:
17047       return FALSE;
17048     }
17049   return TRUE;
17050 }
17051
17052 /* Print the name of the symbol associated with a build attribute
17053    that is attached to address OFFSET.  */
17054
17055 static bfd_boolean
17056 print_symbol_for_build_attribute (FILE *         file,
17057                                   unsigned long  offset,
17058                                   bfd_boolean    is_open_attr)
17059 {
17060   static FILE *             saved_file = NULL;
17061   static char *             strtab;
17062   static unsigned long      strtablen;
17063   static Elf_Internal_Sym * symtab;
17064   static unsigned long      nsyms;
17065   Elf_Internal_Sym *        saved_sym = NULL;
17066   Elf_Internal_Sym *        sym;
17067
17068   if (section_headers != NULL
17069       && (saved_file == NULL || file != saved_file))
17070     {
17071       Elf_Internal_Shdr * symsec;
17072
17073       /* Load the symbol and string sections.  */
17074       for (symsec = section_headers;
17075            symsec < section_headers + elf_header.e_shnum;
17076            symsec ++)
17077         {
17078           if (symsec->sh_type == SHT_SYMTAB)
17079             {
17080               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17081
17082               if (symsec->sh_link < elf_header.e_shnum)
17083                 {
17084                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17085
17086                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17087                                               1, strtab_sec->sh_size,
17088                                               _("string table"));
17089                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17090                 }
17091             }
17092         }
17093       saved_file = file;
17094     }
17095
17096   if (symtab == NULL || strtab == NULL)
17097     {
17098       printf ("\n");
17099       return FALSE;
17100     }
17101
17102   /* Find a symbol whose value matches offset.  */
17103   for (sym = symtab; sym < symtab + nsyms; sym ++)
17104     if (sym->st_value == offset)
17105       {
17106         if (sym->st_name >= strtablen)
17107           /* Huh ?  This should not happen.  */
17108           continue;
17109
17110         if (strtab[sym->st_name] == 0)
17111           continue;
17112
17113         if (is_open_attr)
17114           {
17115             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17116                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17117                FUNC symbols entirely.  */
17118             switch (ELF_ST_TYPE (sym->st_info))
17119               {
17120               case STT_FILE:
17121                 saved_sym = sym;
17122                 /* We can stop searching now.  */
17123                 sym = symtab + nsyms;
17124                 continue;
17125
17126               case STT_OBJECT:
17127                 saved_sym = sym;
17128                 continue;
17129
17130               case STT_FUNC:
17131                 /* Ignore function symbols.  */
17132                 continue;
17133
17134               default:
17135                 break;
17136               }
17137
17138             switch (ELF_ST_BIND (sym->st_info))
17139               {
17140               case STB_GLOBAL:
17141                 if (saved_sym == NULL
17142                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17143                   saved_sym = sym;
17144                 break;
17145
17146               case STB_LOCAL:
17147                 if (saved_sym == NULL)
17148                   saved_sym = sym;
17149                 break;
17150
17151               default:
17152                 break;
17153               }
17154           }
17155         else
17156           {
17157             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17158               continue;
17159
17160             saved_sym = sym;
17161             break;
17162           }
17163       }
17164
17165   printf (" (%s: %s)\n",
17166           is_open_attr ? _("file") : _("func"),
17167           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17168   return TRUE;
17169 }
17170
17171 static bfd_boolean
17172 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17173                                        FILE *              file)
17174 {
17175   static unsigned long global_offset = 0;
17176   unsigned long        offset;
17177   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17178   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17179
17180   if (pnote->descsz == 0)
17181     {
17182       if (is_open_attr)
17183         {
17184           printf (_("    Applies from offset %#lx\n"), global_offset);
17185           return TRUE;
17186         }
17187       else
17188         {
17189           printf (_("    Applies to func at %#lx"), global_offset);
17190           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17191         }
17192     }
17193
17194   if (pnote->descsz != desc_size)
17195     {
17196       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17197       printf (_("    <invalid descsz>"));
17198       return FALSE;
17199     }
17200
17201   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17202
17203   if (is_open_attr)
17204     {
17205       printf (_("    Applies from offset %#lx"), offset);
17206       global_offset = offset;
17207     }
17208   else
17209     {
17210       printf (_("    Applies to func at %#lx"), offset);
17211     }
17212
17213   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17214 }
17215
17216 static bfd_boolean
17217 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17218 {
17219   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17220   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17221   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17222   char         name_type;
17223   char         name_attribute;
17224   const char * expected_types;
17225   const char * name = pnote->namedata;
17226   const char * text;
17227   signed int   left;
17228
17229   if (name == NULL || pnote->namesz < 2)
17230     {
17231       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17232       print_symbol (-20, _("  <corrupt name>"));
17233       return FALSE;
17234     }
17235
17236   left = 20;
17237
17238   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17239   if (name[0] == 'G' && name[1] == 'A')
17240     {
17241       printf ("GA");
17242       name += 2;
17243       left -= 2;
17244     }
17245
17246   switch ((name_type = * name))
17247     {
17248     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17249     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17250     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17251     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17252       printf ("%c", * name);
17253       left --;
17254       break;
17255     default:
17256       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17257       print_symbol (-20, _("<unknown name type>"));
17258       return FALSE;
17259     }
17260
17261   ++ name;
17262   text = NULL;
17263
17264   switch ((name_attribute = * name))
17265     {
17266     case GNU_BUILD_ATTRIBUTE_VERSION:
17267       text = _("<version>");
17268       expected_types = string_expected;
17269       ++ name;
17270       break;
17271     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17272       text = _("<stack prot>");
17273       expected_types = "!+*";
17274       ++ name;
17275       break;
17276     case GNU_BUILD_ATTRIBUTE_RELRO:
17277       text = _("<relro>");
17278       expected_types = bool_expected;
17279       ++ name;
17280       break;
17281     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17282       text = _("<stack size>");
17283       expected_types = number_expected;
17284       ++ name;
17285       break;
17286     case GNU_BUILD_ATTRIBUTE_TOOL:
17287       text = _("<tool>");
17288       expected_types = string_expected;
17289       ++ name;
17290       break;
17291     case GNU_BUILD_ATTRIBUTE_ABI:
17292       text = _("<ABI>");
17293       expected_types = "$*";
17294       ++ name;
17295       break;
17296     case GNU_BUILD_ATTRIBUTE_PIC:
17297       text = _("<PIC>");
17298       expected_types = number_expected;
17299       ++ name;
17300       break;
17301     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17302       text = _("<short enum>");
17303       expected_types = bool_expected;
17304       ++ name;
17305       break;
17306     default:
17307       if (ISPRINT (* name))
17308         {
17309           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17310
17311           if (len > left && ! do_wide)
17312             len = left;
17313           printf ("%.*s:", len, name);
17314           left -= len;
17315           name += len;
17316         }
17317       else
17318         {
17319           static char tmpbuf [128];
17320
17321           error (_("unrecognised byte in name field: %d\n"), * name);
17322           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17323           text = tmpbuf;
17324           name ++;
17325         }
17326       expected_types = "*$!+";
17327       break;
17328     }
17329
17330   if (text)
17331     left -= printf ("%s", text);
17332
17333   if (strchr (expected_types, name_type) == NULL)
17334     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17335
17336   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17337     {
17338       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17339              (unsigned long) pnote->namesz,
17340              (long) (name - pnote->namedata));
17341       return FALSE;
17342     }
17343
17344   if (left < 1 && ! do_wide)
17345     return TRUE;
17346
17347   switch (name_type)
17348     {
17349     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17350       {
17351         unsigned int        bytes;
17352         unsigned long long  val = 0;
17353         unsigned int        shift = 0;
17354         char *              decoded = NULL;
17355
17356         bytes = pnote->namesz - (name - pnote->namedata);
17357         if (bytes > 0)
17358           /* The -1 is because the name field is always 0 terminated, and we
17359              want to be able to ensure that the shift in the while loop below
17360              will not overflow.  */
17361           -- bytes;
17362
17363         if (bytes > sizeof (val))
17364           {
17365             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17366                      pnote->namesz, name, pnote->namedata);
17367             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17368                    bytes);
17369             bytes = sizeof (val);
17370           }
17371         /* We do not bother to warn if bytes == 0 as this can
17372            happen with some early versions of the gcc plugin.  */
17373
17374         while (bytes --)
17375           {
17376             unsigned long byte = (* name ++) & 0xff;
17377
17378             val |= byte << shift;
17379             shift += 8;
17380           }
17381
17382         switch (name_attribute)
17383           {
17384           case GNU_BUILD_ATTRIBUTE_PIC:
17385             switch (val)
17386               {
17387               case 0: decoded = "static"; break;
17388               case 1: decoded = "pic"; break;
17389               case 2: decoded = "PIC"; break;
17390               case 3: decoded = "pie"; break;
17391               case 4: decoded = "PIE"; break;
17392               default: break;
17393               }
17394             break;
17395           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17396             switch (val)
17397               {
17398                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17399               case 0: decoded = "off"; break;
17400               case 1: decoded = "on"; break;
17401               case 2: decoded = "all"; break;
17402               case 3: decoded = "strong"; break;
17403               case 4: decoded = "explicit"; break;
17404               default: break;
17405               }
17406             break;
17407           default:
17408             break;
17409           }
17410
17411         if (decoded != NULL)
17412           {
17413             print_symbol (-left, decoded);
17414             left = 0;
17415           }
17416         else if (val == 0)
17417           {
17418             printf ("0x0");
17419             left -= 3;
17420           }
17421         else
17422           {
17423             if (do_wide)
17424               left -= printf ("0x%llx", val);
17425             else
17426               left -= printf ("0x%-.*llx", left, val);
17427           }
17428       }
17429       break;
17430     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17431       left -= print_symbol (- left, name);
17432       break;
17433     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17434       left -= print_symbol (- left, "true");
17435       break;
17436     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17437       left -= print_symbol (- left, "false");
17438       break;
17439     }
17440
17441   if (do_wide && left > 0)
17442     printf ("%-*s", left, " ");
17443
17444   return TRUE;
17445 }
17446
17447 /* Note that by the ELF standard, the name field is already null byte
17448    terminated, and namesz includes the terminating null byte.
17449    I.E. the value of namesz for the name "FSF" is 4.
17450
17451    If the value of namesz is zero, there is no name present.  */
17452
17453 static bfd_boolean
17454 process_note (Elf_Internal_Note *  pnote,
17455               FILE *               file)
17456 {
17457   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17458   const char * nt;
17459
17460   if (pnote->namesz == 0)
17461     /* If there is no note name, then use the default set of
17462        note type strings.  */
17463     nt = get_note_type (pnote->type);
17464
17465   else if (const_strneq (pnote->namedata, "GNU"))
17466     /* GNU-specific object file notes.  */
17467     nt = get_gnu_elf_note_type (pnote->type);
17468
17469   else if (const_strneq (pnote->namedata, "FreeBSD"))
17470     /* FreeBSD-specific core file notes.  */
17471     nt = get_freebsd_elfcore_note_type (pnote->type);
17472
17473   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17474     /* NetBSD-specific core file notes.  */
17475     nt = get_netbsd_elfcore_note_type (pnote->type);
17476
17477   else if (const_strneq (pnote->namedata, "NetBSD"))
17478     /* NetBSD-specific core file notes.  */
17479     return process_netbsd_elf_note (pnote);
17480
17481   else if (strneq (pnote->namedata, "SPU/", 4))
17482     {
17483       /* SPU-specific core file notes.  */
17484       nt = pnote->namedata + 4;
17485       name = "SPU";
17486     }
17487
17488   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17489     /* VMS/ia64-specific file notes.  */
17490     nt = get_ia64_vms_note_type (pnote->type);
17491
17492   else if (const_strneq (pnote->namedata, "stapsdt"))
17493     nt = get_stapsdt_note_type (pnote->type);
17494
17495   else
17496     /* Don't recognize this note name; just use the default set of
17497        note type strings.  */
17498     nt = get_note_type (pnote->type);
17499
17500   printf ("  ");
17501
17502   if (((const_strneq (pnote->namedata, "GA")
17503         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17504        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17505       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17506           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17507     print_gnu_build_attribute_name (pnote);
17508   else
17509     print_symbol (-20, name);
17510
17511   if (do_wide)
17512     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17513   else
17514     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17515
17516   if (const_strneq (pnote->namedata, "IPF/VMS"))
17517     return print_ia64_vms_note (pnote);
17518   else if (const_strneq (pnote->namedata, "GNU"))
17519     return print_gnu_note (pnote);
17520   else if (const_strneq (pnote->namedata, "stapsdt"))
17521     return print_stapsdt_note (pnote);
17522   else if (const_strneq (pnote->namedata, "CORE"))
17523     return print_core_note (pnote);
17524   else if (((const_strneq (pnote->namedata, "GA")
17525              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17526             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17527            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17528                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17529     return print_gnu_build_attribute_description (pnote, file);
17530
17531   if (pnote->descsz)
17532     {
17533       unsigned long i;
17534
17535       printf (_("   description data: "));
17536       for (i = 0; i < pnote->descsz; i++)
17537         printf ("%02x ", pnote->descdata[i]);
17538       if (!do_wide)
17539         printf ("\n");
17540     }
17541
17542   if (do_wide)
17543     printf ("\n");
17544
17545   return TRUE;
17546 }
17547
17548 static bfd_boolean
17549 process_notes_at (FILE *              file,
17550                   Elf_Internal_Shdr * section,
17551                   bfd_vma             offset,
17552                   bfd_vma             length)
17553 {
17554   Elf_External_Note * pnotes;
17555   Elf_External_Note * external;
17556   char * end;
17557   bfd_boolean res = TRUE;
17558
17559   if (length <= 0)
17560     return FALSE;
17561
17562   if (section)
17563     {
17564       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17565       if (pnotes)
17566         {
17567           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17568             return FALSE;
17569         }
17570     }
17571   else
17572     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17573                                              _("notes"));
17574   if (pnotes == NULL)
17575     return FALSE;
17576
17577   external = pnotes;
17578
17579   if (section)
17580     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17581   else
17582     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17583             (unsigned long) offset, (unsigned long) length);
17584
17585   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17586
17587   end = (char *) pnotes + length;
17588   while ((char *) external < end)
17589     {
17590       Elf_Internal_Note inote;
17591       size_t min_notesz;
17592       char *next;
17593       char * temp = NULL;
17594       size_t data_remaining = end - (char *) external;
17595
17596       if (!is_ia64_vms ())
17597         {
17598           /* PR binutils/15191
17599              Make sure that there is enough data to read.  */
17600           min_notesz = offsetof (Elf_External_Note, name);
17601           if (data_remaining < min_notesz)
17602             {
17603               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17604                     (int) data_remaining);
17605               break;
17606             }
17607           inote.type     = BYTE_GET (external->type);
17608           inote.namesz   = BYTE_GET (external->namesz);
17609           inote.namedata = external->name;
17610           inote.descsz   = BYTE_GET (external->descsz);
17611           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17612           /* PR 17531: file: 3443835e.  */
17613           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17614             {
17615               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17616                     inote.namesz, (long)(end - inote.namedata));
17617               inote.descdata = inote.namedata;
17618               inote.namesz   = 0;
17619             }
17620
17621           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17622           next = inote.descdata + align_power (inote.descsz, 2);
17623         }
17624       else
17625         {
17626           Elf64_External_VMS_Note *vms_external;
17627
17628           /* PR binutils/15191
17629              Make sure that there is enough data to read.  */
17630           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17631           if (data_remaining < min_notesz)
17632             {
17633               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17634                     (int) data_remaining);
17635               break;
17636             }
17637
17638           vms_external = (Elf64_External_VMS_Note *) external;
17639           inote.type     = BYTE_GET (vms_external->type);
17640           inote.namesz   = BYTE_GET (vms_external->namesz);
17641           inote.namedata = vms_external->name;
17642           inote.descsz   = BYTE_GET (vms_external->descsz);
17643           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17644           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17645           next = inote.descdata + align_power (inote.descsz, 3);
17646         }
17647
17648       if (inote.descdata < (char *) external + min_notesz
17649           || next < (char *) external + min_notesz
17650           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17651           || inote.namedata + inote.namesz < inote.namedata
17652           || inote.descdata + inote.descsz < inote.descdata
17653           || data_remaining < (size_t)(next - (char *) external))
17654         {
17655           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17656                 (unsigned long) ((char *) external - (char *) pnotes));
17657           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17658                 inote.type, inote.namesz, inote.descsz);
17659           break;
17660         }
17661
17662       external = (Elf_External_Note *) next;
17663
17664       /* Verify that name is null terminated.  It appears that at least
17665          one version of Linux (RedHat 6.0) generates corefiles that don't
17666          comply with the ELF spec by failing to include the null byte in
17667          namesz.  */
17668       if (inote.namedata[inote.namesz - 1] != '\0')
17669         {
17670           temp = (char *) malloc (inote.namesz + 1);
17671           if (temp == NULL)
17672             {
17673               error (_("Out of memory allocating space for inote name\n"));
17674               res = FALSE;
17675               break;
17676             }
17677
17678           memcpy (temp, inote.namedata, inote.namesz);
17679           temp[inote.namesz] = 0;
17680
17681           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17682           inote.namedata = temp;
17683         }
17684
17685       if (! process_note (& inote, file))
17686         res = FALSE;
17687
17688       if (temp != NULL)
17689         {
17690           free (temp);
17691           temp = NULL;
17692         }
17693     }
17694
17695   free (pnotes);
17696
17697   return res;
17698 }
17699
17700 static bfd_boolean
17701 process_corefile_note_segments (FILE * file)
17702 {
17703   Elf_Internal_Phdr * segment;
17704   unsigned int i;
17705   bfd_boolean res = TRUE;
17706
17707   if (! get_program_headers (file))
17708     return TRUE;
17709
17710   for (i = 0, segment = program_headers;
17711        i < elf_header.e_phnum;
17712        i++, segment++)
17713     {
17714       if (segment->p_type == PT_NOTE)
17715         if (! process_notes_at (file, NULL,
17716                                 (bfd_vma) segment->p_offset,
17717                                 (bfd_vma) segment->p_filesz))
17718           res = FALSE;
17719     }
17720
17721   return res;
17722 }
17723
17724 static bfd_boolean
17725 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17726 {
17727   Elf_External_Note * pnotes;
17728   Elf_External_Note * external;
17729   char * end;
17730   bfd_boolean res = TRUE;
17731
17732   if (length <= 0)
17733     return FALSE;
17734
17735   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17736                                            _("v850 notes"));
17737   if (pnotes == NULL)
17738     return FALSE;
17739
17740   external = pnotes;
17741   end = (char*) pnotes + length;
17742
17743   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17744           (unsigned long) offset, (unsigned long) length);
17745
17746   while ((char *) external + sizeof (Elf_External_Note) < end)
17747     {
17748       Elf_External_Note * next;
17749       Elf_Internal_Note inote;
17750
17751       inote.type     = BYTE_GET (external->type);
17752       inote.namesz   = BYTE_GET (external->namesz);
17753       inote.namedata = external->name;
17754       inote.descsz   = BYTE_GET (external->descsz);
17755       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17756       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17757
17758       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17759         {
17760           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17761           inote.descdata = inote.namedata;
17762           inote.namesz   = 0;
17763         }
17764
17765       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17766
17767       if (   ((char *) next > end)
17768           || ((char *) next <  (char *) pnotes))
17769         {
17770           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17771                 (unsigned long) ((char *) external - (char *) pnotes));
17772           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17773                 inote.type, inote.namesz, inote.descsz);
17774           break;
17775         }
17776
17777       external = next;
17778
17779       /* Prevent out-of-bounds indexing.  */
17780       if (   inote.namedata + inote.namesz > end
17781           || inote.namedata + inote.namesz < inote.namedata)
17782         {
17783           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17784                 (unsigned long) ((char *) external - (char *) pnotes));
17785           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17786                 inote.type, inote.namesz, inote.descsz);
17787           break;
17788         }
17789
17790       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17791
17792       if (! print_v850_note (& inote))
17793         {
17794           res = FALSE;
17795           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17796                   inote.namesz, inote.descsz);
17797         }
17798     }
17799
17800   free (pnotes);
17801
17802   return res;
17803 }
17804
17805 static bfd_boolean
17806 process_note_sections (FILE * file)
17807 {
17808   Elf_Internal_Shdr * section;
17809   unsigned long i;
17810   unsigned int n = 0;
17811   bfd_boolean res = TRUE;
17812
17813   for (i = 0, section = section_headers;
17814        i < elf_header.e_shnum && section != NULL;
17815        i++, section++)
17816     {
17817       if (section->sh_type == SHT_NOTE)
17818         {
17819           if (! process_notes_at (file, section,
17820                                   (bfd_vma) section->sh_offset,
17821                                   (bfd_vma) section->sh_size))
17822             res = FALSE;
17823           n++;
17824         }
17825
17826       if ((   elf_header.e_machine == EM_V800
17827            || elf_header.e_machine == EM_V850
17828            || elf_header.e_machine == EM_CYGNUS_V850)
17829           && section->sh_type == SHT_RENESAS_INFO)
17830         {
17831           if (! process_v850_notes (file,
17832                                     (bfd_vma) section->sh_offset,
17833                                     (bfd_vma) section->sh_size))
17834             res = FALSE;
17835           n++;
17836         }
17837     }
17838
17839   if (n == 0)
17840     /* Try processing NOTE segments instead.  */
17841     return process_corefile_note_segments (file);
17842
17843   return res;
17844 }
17845
17846 static bfd_boolean
17847 process_notes (FILE * file)
17848 {
17849   /* If we have not been asked to display the notes then do nothing.  */
17850   if (! do_notes)
17851     return TRUE;
17852
17853   if (elf_header.e_type != ET_CORE)
17854     return process_note_sections (file);
17855
17856   /* No program headers means no NOTE segment.  */
17857   if (elf_header.e_phnum > 0)
17858     return process_corefile_note_segments (file);
17859
17860   printf (_("No note segments present in the core file.\n"));
17861   return TRUE;
17862 }
17863
17864 static unsigned char *
17865 display_public_gnu_attributes (unsigned char * start,
17866                                const unsigned char * const end)
17867 {
17868   printf (_("  Unknown GNU attribute: %s\n"), start);
17869
17870   start += strnlen ((char *) start, end - start);
17871   display_raw_attribute (start, end);
17872
17873   return (unsigned char *) end;
17874 }
17875
17876 static unsigned char *
17877 display_generic_attribute (unsigned char * start,
17878                            unsigned int tag,
17879                            const unsigned char * const end)
17880 {
17881   if (tag == 0)
17882     return (unsigned char *) end;
17883
17884   return display_tag_value (tag, start, end);
17885 }
17886
17887 static bfd_boolean
17888 process_arch_specific (FILE * file)
17889 {
17890   if (! do_arch)
17891     return TRUE;
17892
17893   switch (elf_header.e_machine)
17894     {
17895     case EM_ARC:
17896     case EM_ARC_COMPACT:
17897     case EM_ARC_COMPACT2:
17898       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17899                                  display_arc_attribute,
17900                                  display_generic_attribute);
17901     case EM_ARM:
17902       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17903                                  display_arm_attribute,
17904                                  display_generic_attribute);
17905
17906     case EM_MIPS:
17907     case EM_MIPS_RS3_LE:
17908       return process_mips_specific (file);
17909
17910     case EM_MSP430:
17911      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17912                                  display_msp430x_attribute,
17913                                  display_generic_attribute);
17914
17915     case EM_NDS32:
17916       return process_nds32_specific (file);
17917
17918     case EM_PPC:
17919     case EM_PPC64:
17920       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17921                                  display_power_gnu_attribute);
17922
17923     case EM_S390:
17924     case EM_S390_OLD:
17925       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17926                                  display_s390_gnu_attribute);
17927
17928     case EM_SPARC:
17929     case EM_SPARC32PLUS:
17930     case EM_SPARCV9:
17931       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17932                                  display_sparc_gnu_attribute);
17933
17934     case EM_TI_C6000:
17935       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17936                                  display_tic6x_attribute,
17937                                  display_generic_attribute);
17938
17939     default:
17940       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17941                                  display_public_gnu_attributes,
17942                                  display_generic_attribute);
17943     }
17944 }
17945
17946 static bfd_boolean
17947 get_file_header (FILE * file)
17948 {
17949   /* Read in the identity array.  */
17950   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17951     return FALSE;
17952
17953   /* Determine how to read the rest of the header.  */
17954   switch (elf_header.e_ident[EI_DATA])
17955     {
17956     default:
17957     case ELFDATANONE:
17958     case ELFDATA2LSB:
17959       byte_get = byte_get_little_endian;
17960       byte_put = byte_put_little_endian;
17961       break;
17962     case ELFDATA2MSB:
17963       byte_get = byte_get_big_endian;
17964       byte_put = byte_put_big_endian;
17965       break;
17966     }
17967
17968   /* For now we only support 32 bit and 64 bit ELF files.  */
17969   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17970
17971   /* Read in the rest of the header.  */
17972   if (is_32bit_elf)
17973     {
17974       Elf32_External_Ehdr ehdr32;
17975
17976       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17977         return FALSE;
17978
17979       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17980       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17981       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17982       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17983       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17984       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17985       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17986       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17987       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17988       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17989       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17990       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17991       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17992     }
17993   else
17994     {
17995       Elf64_External_Ehdr ehdr64;
17996
17997       /* If we have been compiled with sizeof (bfd_vma) == 4, then
17998          we will not be able to cope with the 64bit data found in
17999          64 ELF files.  Detect this now and abort before we start
18000          overwriting things.  */
18001       if (sizeof (bfd_vma) < 8)
18002         {
18003           error (_("This instance of readelf has been built without support for a\n\
18004 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18005           return FALSE;
18006         }
18007
18008       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18009         return FALSE;
18010
18011       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
18012       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18013       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
18014       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18015       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18016       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18017       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18018       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18019       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18020       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18021       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18022       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18023       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18024     }
18025
18026   if (elf_header.e_shoff)
18027     {
18028       /* There may be some extensions in the first section header.  Don't
18029          bomb if we can't read it.  */
18030       if (is_32bit_elf)
18031         get_32bit_section_headers (file, TRUE);
18032       else
18033         get_64bit_section_headers (file, TRUE);
18034     }
18035
18036   return TRUE;
18037 }
18038
18039 /* Process one ELF object file according to the command line options.
18040    This file may actually be stored in an archive.  The file is
18041    positioned at the start of the ELF object.  Returns TRUE if no
18042    problems were encountered, FALSE otherwise.  */
18043
18044 static bfd_boolean
18045 process_object (char * file_name, FILE * file)
18046 {
18047   unsigned int i;
18048   bfd_boolean res = TRUE;
18049
18050   if (! get_file_header (file))
18051     {
18052       error (_("%s: Failed to read file header\n"), file_name);
18053       return FALSE;
18054     }
18055
18056   /* Initialise per file variables.  */
18057   for (i = ARRAY_SIZE (version_info); i--;)
18058     version_info[i] = 0;
18059
18060   for (i = ARRAY_SIZE (dynamic_info); i--;)
18061     dynamic_info[i] = 0;
18062   dynamic_info_DT_GNU_HASH = 0;
18063
18064   /* Process the file.  */
18065   if (show_name)
18066     printf (_("\nFile: %s\n"), file_name);
18067
18068   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18069      Note we do this even if cmdline_dump_sects is empty because we
18070      must make sure that the dump_sets array is zeroed out before each
18071      object file is processed.  */
18072   if (num_dump_sects > num_cmdline_dump_sects)
18073     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18074
18075   if (num_cmdline_dump_sects > 0)
18076     {
18077       if (num_dump_sects == 0)
18078         /* A sneaky way of allocating the dump_sects array.  */
18079         request_dump_bynumber (num_cmdline_dump_sects, 0);
18080
18081       assert (num_dump_sects >= num_cmdline_dump_sects);
18082       memcpy (dump_sects, cmdline_dump_sects,
18083               num_cmdline_dump_sects * sizeof (* dump_sects));
18084     }
18085
18086   if (! process_file_header ())
18087     return FALSE;
18088
18089   if (! process_section_headers (file))
18090     {
18091       /* Without loaded section headers we cannot process lots of things.  */
18092       do_unwind = do_version = do_dump = do_arch = FALSE;
18093
18094       if (! do_using_dynamic)
18095         do_syms = do_dyn_syms = do_reloc = FALSE;
18096     }
18097
18098   if (! process_section_groups (file))
18099     /* Without loaded section groups we cannot process unwind.  */
18100     do_unwind = FALSE;
18101
18102   if (process_program_headers (file))
18103     process_dynamic_section (file);
18104   else
18105     res = FALSE;
18106
18107   if (! process_relocs (file))
18108     res = FALSE;
18109
18110   if (! process_unwind (file))
18111     res = FALSE;
18112
18113   if (! process_symbol_table (file))
18114     res = FALSE;
18115
18116   if (! process_syminfo (file))
18117     res = FALSE;
18118
18119   if (! process_version_sections (file))
18120     res = FALSE;
18121
18122   if (! process_section_contents (file))
18123     res = FALSE;
18124
18125   if (! process_notes (file))
18126     res = FALSE;
18127
18128   if (! process_gnu_liblist (file))
18129     res = FALSE;
18130
18131   if (! process_arch_specific (file))
18132     res = FALSE;
18133
18134   if (program_headers)
18135     {
18136       free (program_headers);
18137       program_headers = NULL;
18138     }
18139
18140   if (section_headers)
18141     {
18142       free (section_headers);
18143       section_headers = NULL;
18144     }
18145
18146   if (string_table)
18147     {
18148       free (string_table);
18149       string_table = NULL;
18150       string_table_length = 0;
18151     }
18152
18153   if (dynamic_strings)
18154     {
18155       free (dynamic_strings);
18156       dynamic_strings = NULL;
18157       dynamic_strings_length = 0;
18158     }
18159
18160   if (dynamic_symbols)
18161     {
18162       free (dynamic_symbols);
18163       dynamic_symbols = NULL;
18164       num_dynamic_syms = 0;
18165     }
18166
18167   if (dynamic_syminfo)
18168     {
18169       free (dynamic_syminfo);
18170       dynamic_syminfo = NULL;
18171     }
18172
18173   if (dynamic_section)
18174     {
18175       free (dynamic_section);
18176       dynamic_section = NULL;
18177     }
18178
18179   if (section_headers_groups)
18180     {
18181       free (section_headers_groups);
18182       section_headers_groups = NULL;
18183     }
18184
18185   if (section_groups)
18186     {
18187       struct group_list * g;
18188       struct group_list * next;
18189
18190       for (i = 0; i < group_count; i++)
18191         {
18192           for (g = section_groups [i].root; g != NULL; g = next)
18193             {
18194               next = g->next;
18195               free (g);
18196             }
18197         }
18198
18199       free (section_groups);
18200       section_groups = NULL;
18201     }
18202
18203   free_debug_memory ();
18204
18205   return res;
18206 }
18207
18208 /* Process an ELF archive.
18209    On entry the file is positioned just after the ARMAG string.
18210    Returns TRUE upon success, FALSE otherwise.  */
18211
18212 static bfd_boolean
18213 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18214 {
18215   struct archive_info arch;
18216   struct archive_info nested_arch;
18217   size_t got;
18218   bfd_boolean ret = TRUE;
18219
18220   show_name = TRUE;
18221
18222   /* The ARCH structure is used to hold information about this archive.  */
18223   arch.file_name = NULL;
18224   arch.file = NULL;
18225   arch.index_array = NULL;
18226   arch.sym_table = NULL;
18227   arch.longnames = NULL;
18228
18229   /* The NESTED_ARCH structure is used as a single-item cache of information
18230      about a nested archive (when members of a thin archive reside within
18231      another regular archive file).  */
18232   nested_arch.file_name = NULL;
18233   nested_arch.file = NULL;
18234   nested_arch.index_array = NULL;
18235   nested_arch.sym_table = NULL;
18236   nested_arch.longnames = NULL;
18237
18238   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18239     {
18240       ret = FALSE;
18241       goto out;
18242     }
18243
18244   if (do_archive_index)
18245     {
18246       if (arch.sym_table == NULL)
18247         error (_("%s: unable to dump the index as none was found\n"), file_name);
18248       else
18249         {
18250           unsigned long i, l;
18251           unsigned long current_pos;
18252
18253           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18254                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18255           current_pos = ftell (file);
18256
18257           for (i = l = 0; i < arch.index_num; i++)
18258             {
18259               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18260                 {
18261                   char * member_name;
18262
18263                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18264
18265                   if (member_name != NULL)
18266                     {
18267                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18268
18269                       if (qualified_name != NULL)
18270                         {
18271                           printf (_("Contents of binary %s at offset "), qualified_name);
18272                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18273                           putchar ('\n');
18274                           free (qualified_name);
18275                         }
18276                     }
18277                 }
18278
18279               if (l >= arch.sym_size)
18280                 {
18281                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18282                          file_name);
18283                   ret = FALSE;
18284                   break;
18285                 }
18286               /* PR 17531: file: 0b6630b2.  */
18287               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18288               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18289             }
18290
18291           if (arch.uses_64bit_indicies)
18292             l = (l + 7) & ~ 7;
18293           else
18294             l += l & 1;
18295
18296           if (l < arch.sym_size)
18297             {
18298               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18299                      file_name, arch.sym_size - l);
18300               ret = FALSE;
18301             }
18302
18303           if (fseek (file, current_pos, SEEK_SET) != 0)
18304             {
18305               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18306               ret = FALSE;
18307               goto out;
18308             }
18309         }
18310
18311       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18312           && !do_segments && !do_header && !do_dump && !do_version
18313           && !do_histogram && !do_debugging && !do_arch && !do_notes
18314           && !do_section_groups && !do_dyn_syms)
18315         {
18316           ret = TRUE; /* Archive index only.  */
18317           goto out;
18318         }
18319     }
18320
18321   while (1)
18322     {
18323       char * name;
18324       size_t namelen;
18325       char * qualified_name;
18326
18327       /* Read the next archive header.  */
18328       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18329         {
18330           error (_("%s: failed to seek to next archive header\n"), file_name);
18331           return FALSE;
18332         }
18333       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18334       if (got != sizeof arch.arhdr)
18335         {
18336           if (got == 0)
18337             break;
18338           error (_("%s: failed to read archive header\n"), file_name);
18339           ret = FALSE;
18340           break;
18341         }
18342       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18343         {
18344           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18345           ret = FALSE;
18346           break;
18347         }
18348
18349       arch.next_arhdr_offset += sizeof arch.arhdr;
18350
18351       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18352       if (archive_file_size & 01)
18353         ++archive_file_size;
18354
18355       name = get_archive_member_name (&arch, &nested_arch);
18356       if (name == NULL)
18357         {
18358           error (_("%s: bad archive file name\n"), file_name);
18359           ret = FALSE;
18360           break;
18361         }
18362       namelen = strlen (name);
18363
18364       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18365       if (qualified_name == NULL)
18366         {
18367           error (_("%s: bad archive file name\n"), file_name);
18368           ret = FALSE;
18369           break;
18370         }
18371
18372       if (is_thin_archive && arch.nested_member_origin == 0)
18373         {
18374           /* This is a proxy for an external member of a thin archive.  */
18375           FILE * member_file;
18376           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18377
18378           if (member_file_name == NULL)
18379             {
18380               ret = FALSE;
18381               break;
18382             }
18383
18384           member_file = fopen (member_file_name, "rb");
18385           if (member_file == NULL)
18386             {
18387               error (_("Input file '%s' is not readable.\n"), member_file_name);
18388               free (member_file_name);
18389               ret = FALSE;
18390               break;
18391             }
18392
18393           archive_file_offset = arch.nested_member_origin;
18394
18395           if (! process_object (qualified_name, member_file))
18396             ret = FALSE;
18397
18398           fclose (member_file);
18399           free (member_file_name);
18400         }
18401       else if (is_thin_archive)
18402         {
18403           /* PR 15140: Allow for corrupt thin archives.  */
18404           if (nested_arch.file == NULL)
18405             {
18406               error (_("%s: contains corrupt thin archive: %s\n"),
18407                      file_name, name);
18408               ret = FALSE;
18409               break;
18410             }
18411
18412           /* This is a proxy for a member of a nested archive.  */
18413           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18414
18415           /* The nested archive file will have been opened and setup by
18416              get_archive_member_name.  */
18417           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18418             {
18419               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18420               ret = FALSE;
18421               break;
18422             }
18423
18424           if (! process_object (qualified_name, nested_arch.file))
18425             ret = FALSE;
18426         }
18427       else
18428         {
18429           archive_file_offset = arch.next_arhdr_offset;
18430           arch.next_arhdr_offset += archive_file_size;
18431
18432           if (! process_object (qualified_name, file))
18433             ret = FALSE;
18434         }
18435
18436       if (dump_sects != NULL)
18437         {
18438           free (dump_sects);
18439           dump_sects = NULL;
18440           num_dump_sects = 0;
18441         }
18442
18443       free (qualified_name);
18444     }
18445
18446  out:
18447   if (nested_arch.file != NULL)
18448     fclose (nested_arch.file);
18449   release_archive (&nested_arch);
18450   release_archive (&arch);
18451
18452   return ret;
18453 }
18454
18455 static bfd_boolean
18456 process_file (char * file_name)
18457 {
18458   FILE * file;
18459   struct stat statbuf;
18460   char armag[SARMAG];
18461   bfd_boolean ret = TRUE;
18462
18463   if (stat (file_name, &statbuf) < 0)
18464     {
18465       if (errno == ENOENT)
18466         error (_("'%s': No such file\n"), file_name);
18467       else
18468         error (_("Could not locate '%s'.  System error message: %s\n"),
18469                file_name, strerror (errno));
18470       return FALSE;
18471     }
18472
18473   if (! S_ISREG (statbuf.st_mode))
18474     {
18475       error (_("'%s' is not an ordinary file\n"), file_name);
18476       return FALSE;
18477     }
18478
18479   file = fopen (file_name, "rb");
18480   if (file == NULL)
18481     {
18482       error (_("Input file '%s' is not readable.\n"), file_name);
18483       return FALSE;
18484     }
18485
18486   if (fread (armag, SARMAG, 1, file) != 1)
18487     {
18488       error (_("%s: Failed to read file's magic number\n"), file_name);
18489       fclose (file);
18490       return FALSE;
18491     }
18492
18493   current_file_size = (bfd_size_type) statbuf.st_size;
18494
18495   if (memcmp (armag, ARMAG, SARMAG) == 0)
18496     {
18497       if (! process_archive (file_name, file, FALSE))
18498         ret = FALSE;
18499     }
18500   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18501     {
18502       if ( ! process_archive (file_name, file, TRUE))
18503         ret = FALSE;
18504     }
18505   else
18506     {
18507       if (do_archive_index)
18508         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18509                file_name);
18510
18511       rewind (file);
18512       archive_file_size = archive_file_offset = 0;
18513
18514       if (! process_object (file_name, file))
18515         ret = FALSE;
18516     }
18517
18518   fclose (file);
18519   current_file_size = 0;
18520
18521   return ret;
18522 }
18523
18524 #ifdef SUPPORT_DISASSEMBLY
18525 /* Needed by the i386 disassembler.  For extra credit, someone could
18526    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18527    symbols.  */
18528
18529 void
18530 print_address (unsigned int addr, FILE * outfile)
18531 {
18532   fprintf (outfile,"0x%8.8x", addr);
18533 }
18534
18535 /* Needed by the i386 disassembler.  */
18536 void
18537 db_task_printsym (unsigned int addr)
18538 {
18539   print_address (addr, stderr);
18540 }
18541 #endif
18542
18543 int
18544 main (int argc, char ** argv)
18545 {
18546   int err;
18547
18548 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18549   setlocale (LC_MESSAGES, "");
18550 #endif
18551 #if defined (HAVE_SETLOCALE)
18552   setlocale (LC_CTYPE, "");
18553 #endif
18554   bindtextdomain (PACKAGE, LOCALEDIR);
18555   textdomain (PACKAGE);
18556
18557   expandargv (&argc, &argv);
18558
18559   parse_args (argc, argv);
18560
18561   if (num_dump_sects > 0)
18562     {
18563       /* Make a copy of the dump_sects array.  */
18564       cmdline_dump_sects = (dump_type *)
18565           malloc (num_dump_sects * sizeof (* dump_sects));
18566       if (cmdline_dump_sects == NULL)
18567         error (_("Out of memory allocating dump request table.\n"));
18568       else
18569         {
18570           memcpy (cmdline_dump_sects, dump_sects,
18571                   num_dump_sects * sizeof (* dump_sects));
18572           num_cmdline_dump_sects = num_dump_sects;
18573         }
18574     }
18575
18576   if (optind < (argc - 1))
18577     show_name = TRUE;
18578   else if (optind >= argc)
18579     {
18580       warn (_("Nothing to do.\n"));
18581       usage (stderr);
18582     }
18583
18584   err = FALSE;
18585   while (optind < argc)
18586     if (! process_file (argv[optind++]))
18587       err = TRUE;
18588
18589   if (dump_sects != NULL)
18590     free (dump_sects);
18591   if (cmdline_dump_sects != NULL)
18592     free (cmdline_dump_sects);
18593
18594   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18595 }