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 also helps.  */
 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         request_dump_bynumber (i, DEBUG_DUMP);
6065       /* Trace sections for Itanium VMS.  */
6066       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6067                 || do_trace_aranges)
6068                && const_strneq (name, ".trace_"))
6069         {
6070           name += sizeof (".trace_") - 1;
6071
6072           if (do_debugging
6073               || (do_trace_info     && streq (name, "info"))
6074               || (do_trace_abbrevs  && streq (name, "abbrev"))
6075               || (do_trace_aranges  && streq (name, "aranges"))
6076               )
6077             request_dump_bynumber (i, DEBUG_DUMP);
6078         }
6079     }
6080
6081   if (! do_sections)
6082     return TRUE;
6083
6084   if (elf_header.e_shnum > 1)
6085     printf (_("\nSection Headers:\n"));
6086   else
6087     printf (_("\nSection Header:\n"));
6088
6089   if (is_32bit_elf)
6090     {
6091       if (do_section_details)
6092         {
6093           printf (_("  [Nr] Name\n"));
6094           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6095         }
6096       else
6097         printf
6098           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6099     }
6100   else if (do_wide)
6101     {
6102       if (do_section_details)
6103         {
6104           printf (_("  [Nr] Name\n"));
6105           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6106         }
6107       else
6108         printf
6109           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6110     }
6111   else
6112     {
6113       if (do_section_details)
6114         {
6115           printf (_("  [Nr] Name\n"));
6116           printf (_("       Type              Address          Offset            Link\n"));
6117           printf (_("       Size              EntSize          Info              Align\n"));
6118         }
6119       else
6120         {
6121           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6122           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6123         }
6124     }
6125
6126   if (do_section_details)
6127     printf (_("       Flags\n"));
6128
6129   for (i = 0, section = section_headers;
6130        i < elf_header.e_shnum;
6131        i++, section++)
6132     {
6133       /* Run some sanity checks on the section header.  */
6134
6135       /* Check the sh_link field.  */
6136       switch (section->sh_type)
6137         {
6138         case SHT_SYMTAB_SHNDX:
6139         case SHT_GROUP:
6140         case SHT_HASH:
6141         case SHT_GNU_HASH:
6142         case SHT_GNU_versym:
6143         case SHT_REL:
6144         case SHT_RELA:
6145           if (section->sh_link < 1
6146               || section->sh_link >= elf_header.e_shnum
6147               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6148                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6149             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6150                   i, section->sh_link);
6151           break;
6152
6153         case SHT_DYNAMIC:
6154         case SHT_SYMTAB:
6155         case SHT_DYNSYM:
6156         case SHT_GNU_verneed:
6157         case SHT_GNU_verdef:
6158         case SHT_GNU_LIBLIST:
6159           if (section->sh_link < 1
6160               || section->sh_link >= elf_header.e_shnum
6161               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6162             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6163                   i, section->sh_link);
6164           break;
6165
6166         case SHT_INIT_ARRAY:
6167         case SHT_FINI_ARRAY:
6168         case SHT_PREINIT_ARRAY:
6169           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6170             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6171                   i, section->sh_link);
6172           break;
6173
6174         default:
6175           /* FIXME: Add support for target specific section types.  */
6176 #if 0     /* Currently we do not check other section types as there are too
6177              many special cases.  Stab sections for example have a type
6178              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6179              section.  */
6180           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6181             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6182                   i, section->sh_link);
6183 #endif
6184           break;
6185         }
6186
6187       /* Check the sh_info field.  */
6188       switch (section->sh_type)
6189         {
6190         case SHT_REL:
6191         case SHT_RELA:
6192           if (section->sh_info < 1
6193               || section->sh_info >= elf_header.e_shnum
6194               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6195                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6196                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6197                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6198                   /* FIXME: Are other section types valid ?  */
6199                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6200             {
6201               if (section->sh_info == 0
6202                   && (streq (SECTION_NAME (section), ".rel.dyn")
6203                       || streq (SECTION_NAME (section), ".rela.dyn")))
6204                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6205                    of zero.  The relocations in these sections may apply
6206                    to many different sections.  */
6207                    ;
6208               else
6209                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6210                       i, section->sh_info);
6211             }
6212           break;
6213
6214         case SHT_DYNAMIC:
6215         case SHT_HASH:
6216         case SHT_SYMTAB_SHNDX:
6217         case SHT_INIT_ARRAY:
6218         case SHT_FINI_ARRAY:
6219         case SHT_PREINIT_ARRAY:
6220           if (section->sh_info != 0)
6221             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6222                   i, section->sh_info);
6223           break;
6224
6225         case SHT_GROUP:
6226         case SHT_SYMTAB:
6227         case SHT_DYNSYM:
6228           /* A symbol index - we assume that it is valid.  */
6229           break;
6230
6231         default:
6232           /* FIXME: Add support for target specific section types.  */
6233           if (section->sh_type == SHT_NOBITS)
6234             /* NOBITS section headers with non-zero sh_info fields can be
6235                created when a binary is stripped of everything but its debug
6236                information.  The stripped sections have their headers
6237                preserved but their types set to SHT_NOBITS.  So do not check
6238                this type of section.  */
6239             ;
6240           else if (section->sh_flags & SHF_INFO_LINK)
6241             {
6242               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6243                 warn (_("[%2u]: Expected link to another section in info field"), i);
6244             }
6245           else if (section->sh_type < SHT_LOOS
6246                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6247                    && section->sh_info != 0)
6248             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6249                   i, section->sh_info);
6250           break;
6251         }
6252
6253       /* Check the sh_size field.  */
6254       if (section->sh_size > current_file_size
6255           && section->sh_type != SHT_NOBITS
6256           && section->sh_type != SHT_NULL
6257           && section->sh_type < SHT_LOOS)
6258         warn (_("Size of section %u is larger than the entire file!\n"), i);
6259
6260       printf ("  [%2u] ", i);
6261       if (do_section_details)
6262         printf ("%s\n      ", printable_section_name (section));
6263       else
6264         print_symbol (-17, SECTION_NAME (section));
6265
6266       printf (do_wide ? " %-15s " : " %-15.15s ",
6267               get_section_type_name (section->sh_type));
6268
6269       if (is_32bit_elf)
6270         {
6271           const char * link_too_big = NULL;
6272
6273           print_vma (section->sh_addr, LONG_HEX);
6274
6275           printf ( " %6.6lx %6.6lx %2.2lx",
6276                    (unsigned long) section->sh_offset,
6277                    (unsigned long) section->sh_size,
6278                    (unsigned long) section->sh_entsize);
6279
6280           if (do_section_details)
6281             fputs ("  ", stdout);
6282           else
6283             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6284
6285           if (section->sh_link >= elf_header.e_shnum)
6286             {
6287               link_too_big = "";
6288               /* The sh_link value is out of range.  Normally this indicates
6289                  an error but it can have special values in Solaris binaries.  */
6290               switch (elf_header.e_machine)
6291                 {
6292                 case EM_386:
6293                 case EM_IAMCU:
6294                 case EM_X86_64:
6295                 case EM_L1OM:
6296                 case EM_K1OM:
6297                 case EM_OLD_SPARCV9:
6298                 case EM_SPARC32PLUS:
6299                 case EM_SPARCV9:
6300                 case EM_SPARC:
6301                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6302                     link_too_big = "BEFORE";
6303                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6304                     link_too_big = "AFTER";
6305                   break;
6306                 default:
6307                   break;
6308                 }
6309             }
6310
6311           if (do_section_details)
6312             {
6313               if (link_too_big != NULL && * link_too_big)
6314                 printf ("<%s> ", link_too_big);
6315               else
6316                 printf ("%2u ", section->sh_link);
6317               printf ("%3u %2lu\n", section->sh_info,
6318                       (unsigned long) section->sh_addralign);
6319             }
6320           else
6321             printf ("%2u %3u %2lu\n",
6322                     section->sh_link,
6323                     section->sh_info,
6324                     (unsigned long) section->sh_addralign);
6325
6326           if (link_too_big && ! * link_too_big)
6327             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6328                   i, section->sh_link);
6329         }
6330       else if (do_wide)
6331         {
6332           print_vma (section->sh_addr, LONG_HEX);
6333
6334           if ((long) section->sh_offset == section->sh_offset)
6335             printf (" %6.6lx", (unsigned long) section->sh_offset);
6336           else
6337             {
6338               putchar (' ');
6339               print_vma (section->sh_offset, LONG_HEX);
6340             }
6341
6342           if ((unsigned long) section->sh_size == section->sh_size)
6343             printf (" %6.6lx", (unsigned long) section->sh_size);
6344           else
6345             {
6346               putchar (' ');
6347               print_vma (section->sh_size, LONG_HEX);
6348             }
6349
6350           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6351             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6352           else
6353             {
6354               putchar (' ');
6355               print_vma (section->sh_entsize, LONG_HEX);
6356             }
6357
6358           if (do_section_details)
6359             fputs ("  ", stdout);
6360           else
6361             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6362
6363           printf ("%2u %3u ", section->sh_link, section->sh_info);
6364
6365           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6366             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6367           else
6368             {
6369               print_vma (section->sh_addralign, DEC);
6370               putchar ('\n');
6371             }
6372         }
6373       else if (do_section_details)
6374         {
6375           printf ("       %-15.15s  ",
6376                   get_section_type_name (section->sh_type));
6377           print_vma (section->sh_addr, LONG_HEX);
6378           if ((long) section->sh_offset == section->sh_offset)
6379             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6380           else
6381             {
6382               printf ("  ");
6383               print_vma (section->sh_offset, LONG_HEX);
6384             }
6385           printf ("  %u\n       ", section->sh_link);
6386           print_vma (section->sh_size, LONG_HEX);
6387           putchar (' ');
6388           print_vma (section->sh_entsize, LONG_HEX);
6389
6390           printf ("  %-16u  %lu\n",
6391                   section->sh_info,
6392                   (unsigned long) section->sh_addralign);
6393         }
6394       else
6395         {
6396           putchar (' ');
6397           print_vma (section->sh_addr, LONG_HEX);
6398           if ((long) section->sh_offset == section->sh_offset)
6399             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6400           else
6401             {
6402               printf ("  ");
6403               print_vma (section->sh_offset, LONG_HEX);
6404             }
6405           printf ("\n       ");
6406           print_vma (section->sh_size, LONG_HEX);
6407           printf ("  ");
6408           print_vma (section->sh_entsize, LONG_HEX);
6409
6410           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6411
6412           printf ("     %2u   %3u     %lu\n",
6413                   section->sh_link,
6414                   section->sh_info,
6415                   (unsigned long) section->sh_addralign);
6416         }
6417
6418       if (do_section_details)
6419         {
6420           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6421           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6422             {
6423               /* Minimum section size is 12 bytes for 32-bit compression
6424                  header + 12 bytes for compressed data header.  */
6425               unsigned char buf[24];
6426
6427               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6428               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6429                             sizeof (buf), _("compression header")))
6430                 {
6431                   Elf_Internal_Chdr chdr;
6432
6433                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6434
6435                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6436                     printf ("       ZLIB, ");
6437                   else
6438                     printf (_("       [<unknown>: 0x%x], "),
6439                             chdr.ch_type);
6440                   print_vma (chdr.ch_size, LONG_HEX);
6441                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6442                 }
6443             }
6444         }
6445     }
6446
6447   if (!do_section_details)
6448     {
6449       /* The ordering of the letters shown here matches the ordering of the
6450          corresponding SHF_xxx values, and hence the order in which these
6451          letters will be displayed to the user.  */
6452       printf (_("Key to Flags:\n\
6453   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6454   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6455   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6456       if (elf_header.e_machine == EM_X86_64
6457           || elf_header.e_machine == EM_L1OM
6458           || elf_header.e_machine == EM_K1OM)
6459         printf (_("l (large), "));
6460       else if (elf_header.e_machine == EM_ARM)
6461         printf (_("y (purecode), "));
6462       printf ("p (processor specific)\n");
6463     }
6464
6465   return TRUE;
6466 }
6467
6468 static const char *
6469 get_group_flags (unsigned int flags)
6470 {
6471   static char buff[128];
6472
6473   if (flags == 0)
6474     return "";
6475   else if (flags == GRP_COMDAT)
6476     return "COMDAT ";
6477
6478   snprintf (buff, 14, _("[0x%x: "), flags);
6479
6480   flags &= ~ GRP_COMDAT;
6481   if (flags & GRP_MASKOS)
6482     {
6483       strcat (buff, "<OS specific>");
6484       flags &= ~ GRP_MASKOS;
6485     }
6486
6487   if (flags & GRP_MASKPROC)
6488     {
6489       strcat (buff, "<PROC specific>");
6490       flags &= ~ GRP_MASKPROC;
6491     }
6492
6493   if (flags)
6494     strcat (buff, "<unknown>");
6495
6496   strcat (buff, "]");
6497   return buff;
6498 }
6499
6500 static bfd_boolean
6501 process_section_groups (FILE * file)
6502 {
6503   Elf_Internal_Shdr * section;
6504   unsigned int i;
6505   struct group * group;
6506   Elf_Internal_Shdr * symtab_sec;
6507   Elf_Internal_Shdr * strtab_sec;
6508   Elf_Internal_Sym * symtab;
6509   unsigned long num_syms;
6510   char * strtab;
6511   size_t strtab_size;
6512
6513   /* Don't process section groups unless needed.  */
6514   if (!do_unwind && !do_section_groups)
6515     return TRUE;
6516
6517   if (elf_header.e_shnum == 0)
6518     {
6519       if (do_section_groups)
6520         printf (_("\nThere are no sections to group in this file.\n"));
6521
6522       return TRUE;
6523     }
6524
6525   if (section_headers == NULL)
6526     {
6527       error (_("Section headers are not available!\n"));
6528       /* PR 13622: This can happen with a corrupt ELF header.  */
6529       return FALSE;
6530     }
6531
6532   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6533                                                      sizeof (struct group *));
6534
6535   if (section_headers_groups == NULL)
6536     {
6537       error (_("Out of memory reading %u section group headers\n"),
6538              elf_header.e_shnum);
6539       return FALSE;
6540     }
6541
6542   /* Scan the sections for the group section.  */
6543   group_count = 0;
6544   for (i = 0, section = section_headers;
6545        i < elf_header.e_shnum;
6546        i++, section++)
6547     if (section->sh_type == SHT_GROUP)
6548       group_count++;
6549
6550   if (group_count == 0)
6551     {
6552       if (do_section_groups)
6553         printf (_("\nThere are no section groups in this file.\n"));
6554
6555       return TRUE;
6556     }
6557
6558   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6559
6560   if (section_groups == NULL)
6561     {
6562       error (_("Out of memory reading %lu groups\n"),
6563              (unsigned long) group_count);
6564       return FALSE;
6565     }
6566
6567   symtab_sec = NULL;
6568   strtab_sec = NULL;
6569   symtab = NULL;
6570   num_syms = 0;
6571   strtab = NULL;
6572   strtab_size = 0;
6573   for (i = 0, section = section_headers, group = section_groups;
6574        i < elf_header.e_shnum;
6575        i++, section++)
6576     {
6577       if (section->sh_type == SHT_GROUP)
6578         {
6579           const char * name = printable_section_name (section);
6580           const char * group_name;
6581           unsigned char * start;
6582           unsigned char * indices;
6583           unsigned int entry, j, size;
6584           Elf_Internal_Shdr * sec;
6585           Elf_Internal_Sym * sym;
6586
6587           /* Get the symbol table.  */
6588           if (section->sh_link >= elf_header.e_shnum
6589               || ((sec = section_headers + section->sh_link)->sh_type
6590                   != SHT_SYMTAB))
6591             {
6592               error (_("Bad sh_link in group section `%s'\n"), name);
6593               continue;
6594             }
6595
6596           if (symtab_sec != sec)
6597             {
6598               symtab_sec = sec;
6599               if (symtab)
6600                 free (symtab);
6601               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6602             }
6603
6604           if (symtab == NULL)
6605             {
6606               error (_("Corrupt header in group section `%s'\n"), name);
6607               continue;
6608             }
6609
6610           if (section->sh_info >= num_syms)
6611             {
6612               error (_("Bad sh_info in group section `%s'\n"), name);
6613               continue;
6614             }
6615
6616           sym = symtab + section->sh_info;
6617
6618           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6619             {
6620               if (sym->st_shndx == 0
6621                   || sym->st_shndx >= elf_header.e_shnum)
6622                 {
6623                   error (_("Bad sh_info in group section `%s'\n"), name);
6624                   continue;
6625                 }
6626
6627               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6628               strtab_sec = NULL;
6629               if (strtab)
6630                 free (strtab);
6631               strtab = NULL;
6632               strtab_size = 0;
6633             }
6634           else
6635             {
6636               /* Get the string table.  */
6637               if (symtab_sec->sh_link >= elf_header.e_shnum)
6638                 {
6639                   strtab_sec = NULL;
6640                   if (strtab)
6641                     free (strtab);
6642                   strtab = NULL;
6643                   strtab_size = 0;
6644                 }
6645               else if (strtab_sec
6646                        != (sec = section_headers + symtab_sec->sh_link))
6647                 {
6648                   strtab_sec = sec;
6649                   if (strtab)
6650                     free (strtab);
6651
6652                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6653                                               1, strtab_sec->sh_size,
6654                                               _("string table"));
6655                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6656                 }
6657               group_name = sym->st_name < strtab_size
6658                 ? strtab + sym->st_name : _("<corrupt>");
6659             }
6660
6661           /* PR 17531: file: loop.  */
6662           if (section->sh_entsize > section->sh_size)
6663             {
6664               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6665                      printable_section_name (section),
6666                      (unsigned long) section->sh_entsize,
6667                      (unsigned long) section->sh_size);
6668               break;
6669             }
6670
6671           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6672                                               1, section->sh_size,
6673                                               _("section data"));
6674           if (start == NULL)
6675             continue;
6676
6677           indices = start;
6678           size = (section->sh_size / section->sh_entsize) - 1;
6679           entry = byte_get (indices, 4);
6680           indices += 4;
6681
6682           if (do_section_groups)
6683             {
6684               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6685                       get_group_flags (entry), i, name, group_name, size);
6686
6687               printf (_("   [Index]    Name\n"));
6688             }
6689
6690           group->group_index = i;
6691
6692           for (j = 0; j < size; j++)
6693             {
6694               struct group_list * g;
6695
6696               entry = byte_get (indices, 4);
6697               indices += 4;
6698
6699               if (entry >= elf_header.e_shnum)
6700                 {
6701                   static unsigned num_group_errors = 0;
6702
6703                   if (num_group_errors ++ < 10)
6704                     {
6705                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6706                              entry, i, elf_header.e_shnum - 1);
6707                       if (num_group_errors == 10)
6708                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6709                     }
6710                   continue;
6711                 }
6712
6713               if (section_headers_groups [entry] != NULL)
6714                 {
6715                   if (entry)
6716                     {
6717                       static unsigned num_errs = 0;
6718
6719                       if (num_errs ++ < 10)
6720                         {
6721                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6722                                  entry, i,
6723                                  section_headers_groups [entry]->group_index);
6724                           if (num_errs == 10)
6725                             warn (_("Further error messages about already contained group sections suppressed\n"));
6726                         }
6727                       continue;
6728                     }
6729                   else
6730                     {
6731                       /* Intel C/C++ compiler may put section 0 in a
6732                          section group.  We just warn it the first time
6733                          and ignore it afterwards.  */
6734                       static bfd_boolean warned = FALSE;
6735                       if (!warned)
6736                         {
6737                           error (_("section 0 in group section [%5u]\n"),
6738                                  section_headers_groups [entry]->group_index);
6739                           warned = TRUE;
6740                         }
6741                     }
6742                 }
6743
6744               section_headers_groups [entry] = group;
6745
6746               if (do_section_groups)
6747                 {
6748                   sec = section_headers + entry;
6749                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6750                 }
6751
6752               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6753               g->section_index = entry;
6754               g->next = group->root;
6755               group->root = g;
6756             }
6757
6758           if (start)
6759             free (start);
6760
6761           group++;
6762         }
6763     }
6764
6765   if (symtab)
6766     free (symtab);
6767   if (strtab)
6768     free (strtab);
6769   return TRUE;
6770 }
6771
6772 /* Data used to display dynamic fixups.  */
6773
6774 struct ia64_vms_dynfixup
6775 {
6776   bfd_vma needed_ident;         /* Library ident number.  */
6777   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6778   bfd_vma fixup_needed;         /* Index of the library.  */
6779   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6780   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6781 };
6782
6783 /* Data used to display dynamic relocations.  */
6784
6785 struct ia64_vms_dynimgrela
6786 {
6787   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6788   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6789 };
6790
6791 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6792    library).  */
6793
6794 static bfd_boolean
6795 dump_ia64_vms_dynamic_fixups (FILE * file,
6796                               struct ia64_vms_dynfixup * fixup,
6797                               const char * strtab,
6798                               unsigned int strtab_sz)
6799 {
6800   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6801   long i;
6802   const char * lib_name;
6803
6804   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6805                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6806                    _("dynamic section image fixups"));
6807   if (!imfs)
6808     return FALSE;
6809
6810   if (fixup->needed < strtab_sz)
6811     lib_name = strtab + fixup->needed;
6812   else
6813     {
6814       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6815             (unsigned long) fixup->needed);
6816       lib_name = "???";
6817     }
6818   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6819           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6820   printf
6821     (_("Seg Offset           Type                             SymVec DataType\n"));
6822
6823   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6824     {
6825       unsigned int type;
6826       const char *rtype;
6827
6828       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6829       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6830       type = BYTE_GET (imfs [i].type);
6831       rtype = elf_ia64_reloc_type (type);
6832       if (rtype == NULL)
6833         printf (" 0x%08x                       ", type);
6834       else
6835         printf (" %-32s ", rtype);
6836       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6837       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6838     }
6839
6840   free (imfs);
6841   return TRUE;
6842 }
6843
6844 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6845
6846 static bfd_boolean
6847 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6848 {
6849   Elf64_External_VMS_IMAGE_RELA *imrs;
6850   long i;
6851
6852   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6853                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6854                    _("dynamic section image relocations"));
6855   if (!imrs)
6856     return FALSE;
6857
6858   printf (_("\nImage relocs\n"));
6859   printf
6860     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6861
6862   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6863     {
6864       unsigned int type;
6865       const char *rtype;
6866
6867       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6868       printf ("%08" BFD_VMA_FMT "x ",
6869               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6870       type = BYTE_GET (imrs [i].type);
6871       rtype = elf_ia64_reloc_type (type);
6872       if (rtype == NULL)
6873         printf ("0x%08x                      ", type);
6874       else
6875         printf ("%-31s ", rtype);
6876       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6877       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6878       printf ("%08" BFD_VMA_FMT "x\n",
6879               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6880     }
6881
6882   free (imrs);
6883   return TRUE;
6884 }
6885
6886 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6887
6888 static bfd_boolean
6889 process_ia64_vms_dynamic_relocs (FILE *file)
6890 {
6891   struct ia64_vms_dynfixup fixup;
6892   struct ia64_vms_dynimgrela imgrela;
6893   Elf_Internal_Dyn *entry;
6894   bfd_vma strtab_off = 0;
6895   bfd_vma strtab_sz = 0;
6896   char *strtab = NULL;
6897   bfd_boolean res = TRUE;
6898
6899   memset (&fixup, 0, sizeof (fixup));
6900   memset (&imgrela, 0, sizeof (imgrela));
6901
6902   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6903   for (entry = dynamic_section;
6904        entry < dynamic_section + dynamic_nent;
6905        entry++)
6906     {
6907       switch (entry->d_tag)
6908         {
6909         case DT_IA_64_VMS_STRTAB_OFFSET:
6910           strtab_off = entry->d_un.d_val;
6911           break;
6912         case DT_STRSZ:
6913           strtab_sz = entry->d_un.d_val;
6914           if (strtab == NULL)
6915             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6916                                1, strtab_sz, _("dynamic string section"));
6917           break;
6918
6919         case DT_IA_64_VMS_NEEDED_IDENT:
6920           fixup.needed_ident = entry->d_un.d_val;
6921           break;
6922         case DT_NEEDED:
6923           fixup.needed = entry->d_un.d_val;
6924           break;
6925         case DT_IA_64_VMS_FIXUP_NEEDED:
6926           fixup.fixup_needed = entry->d_un.d_val;
6927           break;
6928         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6929           fixup.fixup_rela_cnt = entry->d_un.d_val;
6930           break;
6931         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6932           fixup.fixup_rela_off = entry->d_un.d_val;
6933           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6934             res = FALSE;
6935           break;
6936         case DT_IA_64_VMS_IMG_RELA_CNT:
6937           imgrela.img_rela_cnt = entry->d_un.d_val;
6938           break;
6939         case DT_IA_64_VMS_IMG_RELA_OFF:
6940           imgrela.img_rela_off = entry->d_un.d_val;
6941           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6942             res = FALSE;
6943           break;
6944
6945         default:
6946           break;
6947         }
6948     }
6949
6950   if (strtab != NULL)
6951     free (strtab);
6952
6953   return res;
6954 }
6955
6956 static struct
6957 {
6958   const char * name;
6959   int reloc;
6960   int size;
6961   int rela;
6962 }
6963   dynamic_relocations [] =
6964 {
6965   { "REL", DT_REL, DT_RELSZ, FALSE },
6966   { "RELA", DT_RELA, DT_RELASZ, TRUE },
6967   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6968 };
6969
6970 /* Process the reloc section.  */
6971
6972 static bfd_boolean
6973 process_relocs (FILE * file)
6974 {
6975   unsigned long rel_size;
6976   unsigned long rel_offset;
6977
6978   if (!do_reloc)
6979     return TRUE;
6980
6981   if (do_using_dynamic)
6982     {
6983       int          is_rela;
6984       const char * name;
6985       bfd_boolean  has_dynamic_reloc;
6986       unsigned int i;
6987
6988       has_dynamic_reloc = FALSE;
6989
6990       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6991         {
6992           is_rela = dynamic_relocations [i].rela;
6993           name = dynamic_relocations [i].name;
6994           rel_size = dynamic_info [dynamic_relocations [i].size];
6995           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6996
6997           if (rel_size)
6998             has_dynamic_reloc = TRUE;
6999
7000           if (is_rela == UNKNOWN)
7001             {
7002               if (dynamic_relocations [i].reloc == DT_JMPREL)
7003                 switch (dynamic_info[DT_PLTREL])
7004                   {
7005                   case DT_REL:
7006                     is_rela = FALSE;
7007                     break;
7008                   case DT_RELA:
7009                     is_rela = TRUE;
7010                     break;
7011                   }
7012             }
7013
7014           if (rel_size)
7015             {
7016               printf
7017                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7018                  name, rel_offset, rel_size);
7019
7020               dump_relocations (file,
7021                                 offset_from_vma (file, rel_offset, rel_size),
7022                                 rel_size,
7023                                 dynamic_symbols, num_dynamic_syms,
7024                                 dynamic_strings, dynamic_strings_length,
7025                                 is_rela, TRUE /* is_dynamic */);
7026             }
7027         }
7028
7029       if (is_ia64_vms ())
7030         if (process_ia64_vms_dynamic_relocs (file))
7031           has_dynamic_reloc = TRUE;
7032
7033       if (! has_dynamic_reloc)
7034         printf (_("\nThere are no dynamic relocations in this file.\n"));
7035     }
7036   else
7037     {
7038       Elf_Internal_Shdr * section;
7039       unsigned long i;
7040       bfd_boolean found = FALSE;
7041
7042       for (i = 0, section = section_headers;
7043            i < elf_header.e_shnum;
7044            i++, section++)
7045         {
7046           if (   section->sh_type != SHT_RELA
7047               && section->sh_type != SHT_REL)
7048             continue;
7049
7050           rel_offset = section->sh_offset;
7051           rel_size   = section->sh_size;
7052
7053           if (rel_size)
7054             {
7055               Elf_Internal_Shdr * strsec;
7056               int is_rela;
7057
7058               printf (_("\nRelocation section "));
7059
7060               if (string_table == NULL)
7061                 printf ("%d", section->sh_name);
7062               else
7063                 printf ("'%s'", printable_section_name (section));
7064
7065               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7066                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7067
7068               is_rela = section->sh_type == SHT_RELA;
7069
7070               if (section->sh_link != 0
7071                   && section->sh_link < elf_header.e_shnum)
7072                 {
7073                   Elf_Internal_Shdr * symsec;
7074                   Elf_Internal_Sym *  symtab;
7075                   unsigned long nsyms;
7076                   unsigned long strtablen = 0;
7077                   char * strtab = NULL;
7078
7079                   symsec = section_headers + section->sh_link;
7080                   if (symsec->sh_type != SHT_SYMTAB
7081                       && symsec->sh_type != SHT_DYNSYM)
7082                     continue;
7083
7084                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7085
7086                   if (symtab == NULL)
7087                     continue;
7088
7089                   if (symsec->sh_link != 0
7090                       && symsec->sh_link < elf_header.e_shnum)
7091                     {
7092                       strsec = section_headers + symsec->sh_link;
7093
7094                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7095                                                   1, strsec->sh_size,
7096                                                   _("string table"));
7097                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7098                     }
7099
7100                   dump_relocations (file, rel_offset, rel_size,
7101                                     symtab, nsyms, strtab, strtablen,
7102                                     is_rela,
7103                                     symsec->sh_type == SHT_DYNSYM);
7104                   if (strtab)
7105                     free (strtab);
7106                   free (symtab);
7107                 }
7108               else
7109                 dump_relocations (file, rel_offset, rel_size,
7110                                   NULL, 0, NULL, 0, is_rela,
7111                                   FALSE /* is_dynamic */);
7112
7113               found = TRUE;
7114             }
7115         }
7116
7117       if (! found)
7118         printf (_("\nThere are no relocations in this file.\n"));
7119     }
7120
7121   return TRUE;
7122 }
7123
7124 /* An absolute address consists of a section and an offset.  If the
7125    section is NULL, the offset itself is the address, otherwise, the
7126    address equals to LOAD_ADDRESS(section) + offset.  */
7127
7128 struct absaddr
7129 {
7130   unsigned short section;
7131   bfd_vma offset;
7132 };
7133
7134 #define ABSADDR(a) \
7135   ((a).section \
7136    ? section_headers [(a).section].sh_addr + (a).offset \
7137    : (a).offset)
7138
7139 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7140    name, if found, and the offset from the symbol to ADDR.  */
7141
7142 static void
7143 find_symbol_for_address (Elf_Internal_Sym * symtab,
7144                          unsigned long      nsyms,
7145                          const char *       strtab,
7146                          unsigned long      strtab_size,
7147                          struct absaddr     addr,
7148                          const char **      symname,
7149                          bfd_vma *          offset)
7150 {
7151   bfd_vma dist = 0x100000;
7152   Elf_Internal_Sym * sym;
7153   Elf_Internal_Sym * beg;
7154   Elf_Internal_Sym * end;
7155   Elf_Internal_Sym * best = NULL;
7156
7157   REMOVE_ARCH_BITS (addr.offset);
7158   beg = symtab;
7159   end = symtab + nsyms;
7160
7161   while (beg < end)
7162     {
7163       bfd_vma value;
7164
7165       sym = beg + (end - beg) / 2;
7166
7167       value = sym->st_value;
7168       REMOVE_ARCH_BITS (value);
7169
7170       if (sym->st_name != 0
7171           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7172           && addr.offset >= value
7173           && addr.offset - value < dist)
7174         {
7175           best = sym;
7176           dist = addr.offset - value;
7177           if (!dist)
7178             break;
7179         }
7180
7181       if (addr.offset < value)
7182         end = sym;
7183       else
7184         beg = sym + 1;
7185     }
7186
7187   if (best)
7188     {
7189       *symname = (best->st_name >= strtab_size
7190                   ? _("<corrupt>") : strtab + best->st_name);
7191       *offset = dist;
7192       return;
7193     }
7194
7195   *symname = NULL;
7196   *offset = addr.offset;
7197 }
7198
7199 static /* signed */ int
7200 symcmp (const void *p, const void *q)
7201 {
7202   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7203   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7204
7205   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7206 }
7207
7208 /* Process the unwind section.  */
7209
7210 #include "unwind-ia64.h"
7211
7212 struct ia64_unw_table_entry
7213 {
7214   struct absaddr start;
7215   struct absaddr end;
7216   struct absaddr info;
7217 };
7218
7219 struct ia64_unw_aux_info
7220 {
7221   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7222   unsigned long                 table_len;      /* Length of unwind table.  */
7223   unsigned char *               info;           /* Unwind info.  */
7224   unsigned long                 info_size;      /* Size of unwind info.  */
7225   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7226   bfd_vma                       seg_base;       /* Starting address of segment.  */
7227   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7228   unsigned long                 nsyms;          /* Number of symbols.  */
7229   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7230   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7231   char *                        strtab;         /* The string table.  */
7232   unsigned long                 strtab_size;    /* Size of string table.  */
7233 };
7234
7235 static bfd_boolean
7236 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7237 {
7238   struct ia64_unw_table_entry * tp;
7239   unsigned long j, nfuns;
7240   int in_body;
7241   bfd_boolean res = TRUE;
7242
7243   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7244   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7245     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7246       aux->funtab[nfuns++] = aux->symtab[j];
7247   aux->nfuns = nfuns;
7248   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7249
7250   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7251     {
7252       bfd_vma stamp;
7253       bfd_vma offset;
7254       const unsigned char * dp;
7255       const unsigned char * head;
7256       const unsigned char * end;
7257       const char * procname;
7258
7259       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7260                                aux->strtab_size, tp->start, &procname, &offset);
7261
7262       fputs ("\n<", stdout);
7263
7264       if (procname)
7265         {
7266           fputs (procname, stdout);
7267
7268           if (offset)
7269             printf ("+%lx", (unsigned long) offset);
7270         }
7271
7272       fputs (">: [", stdout);
7273       print_vma (tp->start.offset, PREFIX_HEX);
7274       fputc ('-', stdout);
7275       print_vma (tp->end.offset, PREFIX_HEX);
7276       printf ("], info at +0x%lx\n",
7277               (unsigned long) (tp->info.offset - aux->seg_base));
7278
7279       /* PR 17531: file: 86232b32.  */
7280       if (aux->info == NULL)
7281         continue;
7282
7283       /* PR 17531: file: 0997b4d1.  */
7284       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7285         {
7286           warn (_("Invalid offset %lx in table entry %ld\n"),
7287                 (long) tp->info.offset, (long) (tp - aux->table));
7288           res = FALSE;
7289           continue;
7290         }
7291
7292       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7293       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7294
7295       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7296               (unsigned) UNW_VER (stamp),
7297               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7298               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7299               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7300               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7301
7302       if (UNW_VER (stamp) != 1)
7303         {
7304           printf (_("\tUnknown version.\n"));
7305           continue;
7306         }
7307
7308       in_body = 0;
7309       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7310       /* PR 17531: file: 16ceda89.  */
7311       if (end > aux->info + aux->info_size)
7312         end = aux->info + aux->info_size;
7313       for (dp = head + 8; dp < end;)
7314         dp = unw_decode (dp, in_body, & in_body, end);
7315     }
7316
7317   free (aux->funtab);
7318
7319   return res;
7320 }
7321
7322 static bfd_boolean
7323 slurp_ia64_unwind_table (FILE * file,
7324                          struct ia64_unw_aux_info * aux,
7325                          Elf_Internal_Shdr * sec)
7326 {
7327   unsigned long size, nrelas, i;
7328   Elf_Internal_Phdr * seg;
7329   struct ia64_unw_table_entry * tep;
7330   Elf_Internal_Shdr * relsec;
7331   Elf_Internal_Rela * rela;
7332   Elf_Internal_Rela * rp;
7333   unsigned char * table;
7334   unsigned char * tp;
7335   Elf_Internal_Sym * sym;
7336   const char * relname;
7337
7338   aux->table_len = 0;
7339
7340   /* First, find the starting address of the segment that includes
7341      this section: */
7342
7343   if (elf_header.e_phnum)
7344     {
7345       if (! get_program_headers (file))
7346           return FALSE;
7347
7348       for (seg = program_headers;
7349            seg < program_headers + elf_header.e_phnum;
7350            ++seg)
7351         {
7352           if (seg->p_type != PT_LOAD)
7353             continue;
7354
7355           if (sec->sh_addr >= seg->p_vaddr
7356               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7357             {
7358               aux->seg_base = seg->p_vaddr;
7359               break;
7360             }
7361         }
7362     }
7363
7364   /* Second, build the unwind table from the contents of the unwind section:  */
7365   size = sec->sh_size;
7366   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7367                                       _("unwind table"));
7368   if (!table)
7369     return FALSE;
7370
7371   aux->table_len = size / (3 * eh_addr_size);
7372   aux->table = (struct ia64_unw_table_entry *)
7373     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7374   tep = aux->table;
7375
7376   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7377     {
7378       tep->start.section = SHN_UNDEF;
7379       tep->end.section   = SHN_UNDEF;
7380       tep->info.section  = SHN_UNDEF;
7381       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7382       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7383       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7384       tep->start.offset += aux->seg_base;
7385       tep->end.offset   += aux->seg_base;
7386       tep->info.offset  += aux->seg_base;
7387     }
7388   free (table);
7389
7390   /* Third, apply any relocations to the unwind table:  */
7391   for (relsec = section_headers;
7392        relsec < section_headers + elf_header.e_shnum;
7393        ++relsec)
7394     {
7395       if (relsec->sh_type != SHT_RELA
7396           || relsec->sh_info >= elf_header.e_shnum
7397           || section_headers + relsec->sh_info != sec)
7398         continue;
7399
7400       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7401                               & rela, & nrelas))
7402         {
7403           free (aux->table);
7404           aux->table = NULL;
7405           aux->table_len = 0;
7406           return FALSE;
7407         }
7408
7409       for (rp = rela; rp < rela + nrelas; ++rp)
7410         {
7411           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7412           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7413
7414           /* PR 17531: file: 9fa67536.  */
7415           if (relname == NULL)
7416             {
7417               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7418               continue;
7419             }
7420
7421           if (! const_strneq (relname, "R_IA64_SEGREL"))
7422             {
7423               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7424               continue;
7425             }
7426
7427           i = rp->r_offset / (3 * eh_addr_size);
7428
7429           /* PR 17531: file: 5bc8d9bf.  */
7430           if (i >= aux->table_len)
7431             {
7432               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7433               continue;
7434             }
7435
7436           switch (rp->r_offset / eh_addr_size % 3)
7437             {
7438             case 0:
7439               aux->table[i].start.section = sym->st_shndx;
7440               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7441               break;
7442             case 1:
7443               aux->table[i].end.section   = sym->st_shndx;
7444               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7445               break;
7446             case 2:
7447               aux->table[i].info.section  = sym->st_shndx;
7448               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7449               break;
7450             default:
7451               break;
7452             }
7453         }
7454
7455       free (rela);
7456     }
7457
7458   return TRUE;
7459 }
7460
7461 static bfd_boolean
7462 ia64_process_unwind (FILE * file)
7463 {
7464   Elf_Internal_Shdr * sec;
7465   Elf_Internal_Shdr * unwsec = NULL;
7466   Elf_Internal_Shdr * strsec;
7467   unsigned long i, unwcount = 0, unwstart = 0;
7468   struct ia64_unw_aux_info aux;
7469   bfd_boolean res = TRUE;
7470
7471   memset (& aux, 0, sizeof (aux));
7472
7473   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7474     {
7475       if (sec->sh_type == SHT_SYMTAB
7476           && sec->sh_link < elf_header.e_shnum)
7477         {
7478           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7479
7480           strsec = section_headers + sec->sh_link;
7481           if (aux.strtab != NULL)
7482             {
7483               error (_("Multiple auxillary string tables encountered\n"));
7484               free (aux.strtab);
7485               res = FALSE;
7486             }
7487           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7488                                           1, strsec->sh_size,
7489                                           _("string table"));
7490           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7491         }
7492       else if (sec->sh_type == SHT_IA_64_UNWIND)
7493         unwcount++;
7494     }
7495
7496   if (!unwcount)
7497     printf (_("\nThere are no unwind sections in this file.\n"));
7498
7499   while (unwcount-- > 0)
7500     {
7501       char * suffix;
7502       size_t len, len2;
7503
7504       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7505            i < elf_header.e_shnum; ++i, ++sec)
7506         if (sec->sh_type == SHT_IA_64_UNWIND)
7507           {
7508             unwsec = sec;
7509             break;
7510           }
7511       /* We have already counted the number of SHT_IA64_UNWIND
7512          sections so the loop above should never fail.  */
7513       assert (unwsec != NULL);
7514
7515       unwstart = i + 1;
7516       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7517
7518       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7519         {
7520           /* We need to find which section group it is in.  */
7521           struct group_list * g;
7522
7523           if (section_headers_groups == NULL
7524               || section_headers_groups [i] == NULL)
7525             i = elf_header.e_shnum;
7526           else
7527             {
7528               g = section_headers_groups [i]->root;
7529
7530               for (; g != NULL; g = g->next)
7531                 {
7532                   sec = section_headers + g->section_index;
7533
7534                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7535                     break;
7536                 }
7537
7538               if (g == NULL)
7539                 i = elf_header.e_shnum;
7540             }
7541         }
7542       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7543         {
7544           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7545           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7546           suffix = SECTION_NAME (unwsec) + len;
7547           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7548                ++i, ++sec)
7549             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7550                 && streq (SECTION_NAME (sec) + len2, suffix))
7551               break;
7552         }
7553       else
7554         {
7555           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7556              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7557           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7558           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7559           suffix = "";
7560           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7561             suffix = SECTION_NAME (unwsec) + len;
7562           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7563                ++i, ++sec)
7564             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7565                 && streq (SECTION_NAME (sec) + len2, suffix))
7566               break;
7567         }
7568
7569       if (i == elf_header.e_shnum)
7570         {
7571           printf (_("\nCould not find unwind info section for "));
7572
7573           if (string_table == NULL)
7574             printf ("%d", unwsec->sh_name);
7575           else
7576             printf ("'%s'", printable_section_name (unwsec));
7577         }
7578       else
7579         {
7580           aux.info_addr = sec->sh_addr;
7581           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7582                                                  sec->sh_size,
7583                                                  _("unwind info"));
7584           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7585
7586           printf (_("\nUnwind section "));
7587
7588           if (string_table == NULL)
7589             printf ("%d", unwsec->sh_name);
7590           else
7591             printf ("'%s'", printable_section_name (unwsec));
7592
7593           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7594                   (unsigned long) unwsec->sh_offset,
7595                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7596
7597           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7598               && aux.table_len > 0)
7599             dump_ia64_unwind (& aux);
7600
7601           if (aux.table)
7602             free ((char *) aux.table);
7603           if (aux.info)
7604             free ((char *) aux.info);
7605           aux.table = NULL;
7606           aux.info = NULL;
7607         }
7608     }
7609
7610   if (aux.symtab)
7611     free (aux.symtab);
7612   if (aux.strtab)
7613     free ((char *) aux.strtab);
7614
7615   return res;
7616 }
7617
7618 struct hppa_unw_table_entry
7619 {
7620   struct absaddr start;
7621   struct absaddr end;
7622   unsigned int Cannot_unwind:1;                 /* 0 */
7623   unsigned int Millicode:1;                     /* 1 */
7624   unsigned int Millicode_save_sr0:1;            /* 2 */
7625   unsigned int Region_description:2;            /* 3..4 */
7626   unsigned int reserved1:1;                     /* 5 */
7627   unsigned int Entry_SR:1;                      /* 6 */
7628   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7629   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7630   unsigned int Args_stored:1;                   /* 16 */
7631   unsigned int Variable_Frame:1;                /* 17 */
7632   unsigned int Separate_Package_Body:1;         /* 18 */
7633   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7634   unsigned int Stack_Overflow_Check:1;          /* 20 */
7635   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7636   unsigned int Ada_Region:1;                    /* 22 */
7637   unsigned int cxx_info:1;                      /* 23 */
7638   unsigned int cxx_try_catch:1;                 /* 24 */
7639   unsigned int sched_entry_seq:1;               /* 25 */
7640   unsigned int reserved2:1;                     /* 26 */
7641   unsigned int Save_SP:1;                       /* 27 */
7642   unsigned int Save_RP:1;                       /* 28 */
7643   unsigned int Save_MRP_in_frame:1;             /* 29 */
7644   unsigned int extn_ptr_defined:1;              /* 30 */
7645   unsigned int Cleanup_defined:1;               /* 31 */
7646
7647   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7648   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7649   unsigned int Large_frame:1;                   /* 2 */
7650   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7651   unsigned int reserved4:1;                     /* 4 */
7652   unsigned int Total_frame_size:27;             /* 5..31 */
7653 };
7654
7655 struct hppa_unw_aux_info
7656 {
7657   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7658   unsigned long                  table_len;     /* Length of unwind table.  */
7659   bfd_vma                        seg_base;      /* Starting address of segment.  */
7660   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7661   unsigned long                  nsyms;         /* Number of symbols.  */
7662   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7663   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7664   char *                         strtab;        /* The string table.  */
7665   unsigned long                  strtab_size;   /* Size of string table.  */
7666 };
7667
7668 static bfd_boolean
7669 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7670 {
7671   struct hppa_unw_table_entry * tp;
7672   unsigned long j, nfuns;
7673   bfd_boolean res = TRUE;
7674
7675   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7676   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7677     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7678       aux->funtab[nfuns++] = aux->symtab[j];
7679   aux->nfuns = nfuns;
7680   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7681
7682   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7683     {
7684       bfd_vma offset;
7685       const char * procname;
7686
7687       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7688                                aux->strtab_size, tp->start, &procname,
7689                                &offset);
7690
7691       fputs ("\n<", stdout);
7692
7693       if (procname)
7694         {
7695           fputs (procname, stdout);
7696
7697           if (offset)
7698             printf ("+%lx", (unsigned long) offset);
7699         }
7700
7701       fputs (">: [", stdout);
7702       print_vma (tp->start.offset, PREFIX_HEX);
7703       fputc ('-', stdout);
7704       print_vma (tp->end.offset, PREFIX_HEX);
7705       printf ("]\n\t");
7706
7707 #define PF(_m) if (tp->_m) printf (#_m " ");
7708 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7709       PF(Cannot_unwind);
7710       PF(Millicode);
7711       PF(Millicode_save_sr0);
7712       /* PV(Region_description);  */
7713       PF(Entry_SR);
7714       PV(Entry_FR);
7715       PV(Entry_GR);
7716       PF(Args_stored);
7717       PF(Variable_Frame);
7718       PF(Separate_Package_Body);
7719       PF(Frame_Extension_Millicode);
7720       PF(Stack_Overflow_Check);
7721       PF(Two_Instruction_SP_Increment);
7722       PF(Ada_Region);
7723       PF(cxx_info);
7724       PF(cxx_try_catch);
7725       PF(sched_entry_seq);
7726       PF(Save_SP);
7727       PF(Save_RP);
7728       PF(Save_MRP_in_frame);
7729       PF(extn_ptr_defined);
7730       PF(Cleanup_defined);
7731       PF(MPE_XL_interrupt_marker);
7732       PF(HP_UX_interrupt_marker);
7733       PF(Large_frame);
7734       PF(Pseudo_SP_Set);
7735       PV(Total_frame_size);
7736 #undef PF
7737 #undef PV
7738     }
7739
7740   printf ("\n");
7741
7742   free (aux->funtab);
7743
7744   return res;
7745 }
7746
7747 static bfd_boolean
7748 slurp_hppa_unwind_table (FILE * file,
7749                          struct hppa_unw_aux_info * aux,
7750                          Elf_Internal_Shdr * sec)
7751 {
7752   unsigned long size, unw_ent_size, nentries, nrelas, i;
7753   Elf_Internal_Phdr * seg;
7754   struct hppa_unw_table_entry * tep;
7755   Elf_Internal_Shdr * relsec;
7756   Elf_Internal_Rela * rela;
7757   Elf_Internal_Rela * rp;
7758   unsigned char * table;
7759   unsigned char * tp;
7760   Elf_Internal_Sym * sym;
7761   const char * relname;
7762
7763   /* First, find the starting address of the segment that includes
7764      this section.  */
7765   if (elf_header.e_phnum)
7766     {
7767       if (! get_program_headers (file))
7768         return FALSE;
7769
7770       for (seg = program_headers;
7771            seg < program_headers + elf_header.e_phnum;
7772            ++seg)
7773         {
7774           if (seg->p_type != PT_LOAD)
7775             continue;
7776
7777           if (sec->sh_addr >= seg->p_vaddr
7778               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7779             {
7780               aux->seg_base = seg->p_vaddr;
7781               break;
7782             }
7783         }
7784     }
7785
7786   /* Second, build the unwind table from the contents of the unwind
7787      section.  */
7788   size = sec->sh_size;
7789   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7790                                       _("unwind table"));
7791   if (!table)
7792     return FALSE;
7793
7794   unw_ent_size = 16;
7795   nentries = size / unw_ent_size;
7796   size = unw_ent_size * nentries;
7797
7798   tep = aux->table = (struct hppa_unw_table_entry *)
7799       xcmalloc (nentries, sizeof (aux->table[0]));
7800
7801   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7802     {
7803       unsigned int tmp1, tmp2;
7804
7805       tep->start.section = SHN_UNDEF;
7806       tep->end.section   = SHN_UNDEF;
7807
7808       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7809       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7810       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7811       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7812
7813       tep->start.offset += aux->seg_base;
7814       tep->end.offset   += aux->seg_base;
7815
7816       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7817       tep->Millicode = (tmp1 >> 30) & 0x1;
7818       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7819       tep->Region_description = (tmp1 >> 27) & 0x3;
7820       tep->reserved1 = (tmp1 >> 26) & 0x1;
7821       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7822       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7823       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7824       tep->Args_stored = (tmp1 >> 15) & 0x1;
7825       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7826       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7827       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7828       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7829       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7830       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7831       tep->cxx_info = (tmp1 >> 8) & 0x1;
7832       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7833       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7834       tep->reserved2 = (tmp1 >> 5) & 0x1;
7835       tep->Save_SP = (tmp1 >> 4) & 0x1;
7836       tep->Save_RP = (tmp1 >> 3) & 0x1;
7837       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7838       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7839       tep->Cleanup_defined = tmp1 & 0x1;
7840
7841       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7842       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7843       tep->Large_frame = (tmp2 >> 29) & 0x1;
7844       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7845       tep->reserved4 = (tmp2 >> 27) & 0x1;
7846       tep->Total_frame_size = tmp2 & 0x7ffffff;
7847     }
7848   free (table);
7849
7850   /* Third, apply any relocations to the unwind table.  */
7851   for (relsec = section_headers;
7852        relsec < section_headers + elf_header.e_shnum;
7853        ++relsec)
7854     {
7855       if (relsec->sh_type != SHT_RELA
7856           || relsec->sh_info >= elf_header.e_shnum
7857           || section_headers + relsec->sh_info != sec)
7858         continue;
7859
7860       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7861                               & rela, & nrelas))
7862         return FALSE;
7863
7864       for (rp = rela; rp < rela + nrelas; ++rp)
7865         {
7866           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7867           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7868
7869           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7870           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7871             {
7872               warn (_("Skipping unexpected relocation type %s\n"), relname);
7873               continue;
7874             }
7875
7876           i = rp->r_offset / unw_ent_size;
7877
7878           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7879             {
7880             case 0:
7881               aux->table[i].start.section = sym->st_shndx;
7882               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7883               break;
7884             case 1:
7885               aux->table[i].end.section   = sym->st_shndx;
7886               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7887               break;
7888             default:
7889               break;
7890             }
7891         }
7892
7893       free (rela);
7894     }
7895
7896   aux->table_len = nentries;
7897
7898   return TRUE;
7899 }
7900
7901 static bfd_boolean
7902 hppa_process_unwind (FILE * file)
7903 {
7904   struct hppa_unw_aux_info aux;
7905   Elf_Internal_Shdr * unwsec = NULL;
7906   Elf_Internal_Shdr * strsec;
7907   Elf_Internal_Shdr * sec;
7908   unsigned long i;
7909   bfd_boolean res = TRUE;
7910
7911   if (string_table == NULL)
7912     return FALSE;
7913
7914   memset (& aux, 0, sizeof (aux));
7915
7916   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7917     {
7918       if (sec->sh_type == SHT_SYMTAB
7919           && sec->sh_link < elf_header.e_shnum)
7920         {
7921           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7922
7923           strsec = section_headers + sec->sh_link;
7924           if (aux.strtab != NULL)
7925             {
7926               error (_("Multiple auxillary string tables encountered\n"));
7927               free (aux.strtab);
7928               res = FALSE;
7929             }
7930           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7931                                           1, strsec->sh_size,
7932                                           _("string table"));
7933           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7934         }
7935       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7936         unwsec = sec;
7937     }
7938
7939   if (!unwsec)
7940     printf (_("\nThere are no unwind sections in this file.\n"));
7941
7942   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7943     {
7944       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7945         {
7946           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7947                   printable_section_name (sec),
7948                   (unsigned long) sec->sh_offset,
7949                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7950
7951           if (! slurp_hppa_unwind_table (file, &aux, sec))
7952             res = FALSE;
7953
7954           if (aux.table_len > 0)
7955             {
7956               if (! dump_hppa_unwind (&aux))
7957                 res = FALSE;
7958             }
7959
7960           if (aux.table)
7961             free ((char *) aux.table);
7962           aux.table = NULL;
7963         }
7964     }
7965
7966   if (aux.symtab)
7967     free (aux.symtab);
7968   if (aux.strtab)
7969     free ((char *) aux.strtab);
7970
7971   return res;
7972 }
7973
7974 struct arm_section
7975 {
7976   unsigned char *      data;            /* The unwind data.  */
7977   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7978   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7979   unsigned long        nrelas;          /* The number of relocations.  */
7980   unsigned int         rel_type;        /* REL or RELA ?  */
7981   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7982 };
7983
7984 struct arm_unw_aux_info
7985 {
7986   FILE *              file;             /* The file containing the unwind sections.  */
7987   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7988   unsigned long       nsyms;            /* Number of symbols.  */
7989   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7990   unsigned long       nfuns;            /* Number of these symbols.  */
7991   char *              strtab;           /* The file's string table.  */
7992   unsigned long       strtab_size;      /* Size of string table.  */
7993 };
7994
7995 static const char *
7996 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7997                         bfd_vma fn, struct absaddr addr)
7998 {
7999   const char *procname;
8000   bfd_vma sym_offset;
8001
8002   if (addr.section == SHN_UNDEF)
8003     addr.offset = fn;
8004
8005   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8006                            aux->strtab_size, addr, &procname,
8007                            &sym_offset);
8008
8009   print_vma (fn, PREFIX_HEX);
8010
8011   if (procname)
8012     {
8013       fputs (" <", stdout);
8014       fputs (procname, stdout);
8015
8016       if (sym_offset)
8017         printf ("+0x%lx", (unsigned long) sym_offset);
8018       fputc ('>', stdout);
8019     }
8020
8021   return procname;
8022 }
8023
8024 static void
8025 arm_free_section (struct arm_section *arm_sec)
8026 {
8027   if (arm_sec->data != NULL)
8028     free (arm_sec->data);
8029
8030   if (arm_sec->rela != NULL)
8031     free (arm_sec->rela);
8032 }
8033
8034 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8035       cached section and install SEC instead.
8036    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8037       and return its valued in * WORDP, relocating if necessary.
8038    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8039       relocation's offset in ADDR.
8040    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8041       into the string table of the symbol associated with the reloc.  If no
8042       reloc was applied store -1 there.
8043    5) Return TRUE upon success, FALSE otherwise.  */
8044
8045 static bfd_boolean
8046 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8047                          struct arm_section *       arm_sec,
8048                          Elf_Internal_Shdr *        sec,
8049                          bfd_vma                    word_offset,
8050                          unsigned int *             wordp,
8051                          struct absaddr *           addr,
8052                          bfd_vma *                  sym_name)
8053 {
8054   Elf_Internal_Rela *rp;
8055   Elf_Internal_Sym *sym;
8056   const char * relname;
8057   unsigned int word;
8058   bfd_boolean wrapped;
8059
8060   if (sec == NULL || arm_sec == NULL)
8061     return FALSE;
8062
8063   addr->section = SHN_UNDEF;
8064   addr->offset = 0;
8065
8066   if (sym_name != NULL)
8067     *sym_name = (bfd_vma) -1;
8068
8069   /* If necessary, update the section cache.  */
8070   if (sec != arm_sec->sec)
8071     {
8072       Elf_Internal_Shdr *relsec;
8073
8074       arm_free_section (arm_sec);
8075
8076       arm_sec->sec = sec;
8077       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8078                                 sec->sh_size, _("unwind data"));
8079       arm_sec->rela = NULL;
8080       arm_sec->nrelas = 0;
8081
8082       for (relsec = section_headers;
8083            relsec < section_headers + elf_header.e_shnum;
8084            ++relsec)
8085         {
8086           if (relsec->sh_info >= elf_header.e_shnum
8087               || section_headers + relsec->sh_info != sec
8088               /* PR 15745: Check the section type as well.  */
8089               || (relsec->sh_type != SHT_REL
8090                   && relsec->sh_type != SHT_RELA))
8091             continue;
8092
8093           arm_sec->rel_type = relsec->sh_type;
8094           if (relsec->sh_type == SHT_REL)
8095             {
8096               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8097                                      relsec->sh_size,
8098                                      & arm_sec->rela, & arm_sec->nrelas))
8099                 return FALSE;
8100             }
8101           else /* relsec->sh_type == SHT_RELA */
8102             {
8103               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8104                                       relsec->sh_size,
8105                                       & arm_sec->rela, & arm_sec->nrelas))
8106                 return FALSE;
8107             }
8108           break;
8109         }
8110
8111       arm_sec->next_rela = arm_sec->rela;
8112     }
8113
8114   /* If there is no unwind data we can do nothing.  */
8115   if (arm_sec->data == NULL)
8116     return FALSE;
8117
8118   /* If the offset is invalid then fail.  */
8119   if (/* PR 21343 *//* PR 18879 */
8120       sec->sh_size < 4
8121       || word_offset > (sec->sh_size - 4)
8122       || ((bfd_signed_vma) word_offset) < 0)
8123     return FALSE;
8124
8125   /* Get the word at the required offset.  */
8126   word = byte_get (arm_sec->data + word_offset, 4);
8127
8128   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8129   if (arm_sec->rela == NULL)
8130     {
8131       * wordp = word;
8132       return TRUE;
8133     }
8134
8135   /* Look through the relocs to find the one that applies to the provided offset.  */
8136   wrapped = FALSE;
8137   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8138     {
8139       bfd_vma prelval, offset;
8140
8141       if (rp->r_offset > word_offset && !wrapped)
8142         {
8143           rp = arm_sec->rela;
8144           wrapped = TRUE;
8145         }
8146       if (rp->r_offset > word_offset)
8147         break;
8148
8149       if (rp->r_offset & 3)
8150         {
8151           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8152                 (unsigned long) rp->r_offset);
8153           continue;
8154         }
8155
8156       if (rp->r_offset < word_offset)
8157         continue;
8158
8159       /* PR 17531: file: 027-161405-0.004  */
8160       if (aux->symtab == NULL)
8161         continue;
8162
8163       if (arm_sec->rel_type == SHT_REL)
8164         {
8165           offset = word & 0x7fffffff;
8166           if (offset & 0x40000000)
8167             offset |= ~ (bfd_vma) 0x7fffffff;
8168         }
8169       else if (arm_sec->rel_type == SHT_RELA)
8170         offset = rp->r_addend;
8171       else
8172         {
8173           error (_("Unknown section relocation type %d encountered\n"),
8174                  arm_sec->rel_type);
8175           break;
8176         }
8177
8178       /* PR 17531 file: 027-1241568-0.004.  */
8179       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8180         {
8181           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8182                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8183           break;
8184         }
8185
8186       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8187       offset += sym->st_value;
8188       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8189
8190       /* Check that we are processing the expected reloc type.  */
8191       if (elf_header.e_machine == EM_ARM)
8192         {
8193           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8194           if (relname == NULL)
8195             {
8196               warn (_("Skipping unknown ARM relocation type: %d\n"),
8197                     (int) ELF32_R_TYPE (rp->r_info));
8198               continue;
8199             }
8200
8201           if (streq (relname, "R_ARM_NONE"))
8202               continue;
8203
8204           if (! streq (relname, "R_ARM_PREL31"))
8205             {
8206               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8207               continue;
8208             }
8209         }
8210       else if (elf_header.e_machine == EM_TI_C6000)
8211         {
8212           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8213           if (relname == NULL)
8214             {
8215               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8216                     (int) ELF32_R_TYPE (rp->r_info));
8217               continue;
8218             }
8219
8220           if (streq (relname, "R_C6000_NONE"))
8221             continue;
8222
8223           if (! streq (relname, "R_C6000_PREL31"))
8224             {
8225               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8226               continue;
8227             }
8228
8229           prelval >>= 1;
8230         }
8231       else
8232         {
8233           /* This function currently only supports ARM and TI unwinders.  */
8234           warn (_("Only TI and ARM unwinders are currently supported\n"));
8235           break;
8236         }
8237
8238       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8239       addr->section = sym->st_shndx;
8240       addr->offset = offset;
8241
8242       if (sym_name)
8243         * sym_name = sym->st_name;
8244       break;
8245     }
8246
8247   *wordp = word;
8248   arm_sec->next_rela = rp;
8249
8250   return TRUE;
8251 }
8252
8253 static const char *tic6x_unwind_regnames[16] =
8254 {
8255   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8256   "A14", "A13", "A12", "A11", "A10",
8257   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8258 };
8259
8260 static void
8261 decode_tic6x_unwind_regmask (unsigned int mask)
8262 {
8263   int i;
8264
8265   for (i = 12; mask; mask >>= 1, i--)
8266     {
8267       if (mask & 1)
8268         {
8269           fputs (tic6x_unwind_regnames[i], stdout);
8270           if (mask > 1)
8271             fputs (", ", stdout);
8272         }
8273     }
8274 }
8275
8276 #define ADVANCE                                                 \
8277   if (remaining == 0 && more_words)                             \
8278     {                                                           \
8279       data_offset += 4;                                         \
8280       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8281                                      data_offset, & word, & addr, NULL))        \
8282         return FALSE;                                           \
8283       remaining = 4;                                            \
8284       more_words--;                                             \
8285     }                                                           \
8286
8287 #define GET_OP(OP)                      \
8288   ADVANCE;                              \
8289   if (remaining)                        \
8290     {                                   \
8291       remaining--;                      \
8292       (OP) = word >> 24;                \
8293       word <<= 8;                       \
8294     }                                   \
8295   else                                  \
8296     {                                   \
8297       printf (_("[Truncated opcode]\n"));       \
8298       return FALSE;                     \
8299     }                                   \
8300   printf ("0x%02x ", OP)
8301
8302 static bfd_boolean
8303 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8304                             unsigned int               word,
8305                             unsigned int               remaining,
8306                             unsigned int               more_words,
8307                             bfd_vma                    data_offset,
8308                             Elf_Internal_Shdr *        data_sec,
8309                             struct arm_section *       data_arm_sec)
8310 {
8311   struct absaddr addr;
8312   bfd_boolean res = TRUE;
8313
8314   /* Decode the unwinding instructions.  */
8315   while (1)
8316     {
8317       unsigned int op, op2;
8318
8319       ADVANCE;
8320       if (remaining == 0)
8321         break;
8322       remaining--;
8323       op = word >> 24;
8324       word <<= 8;
8325
8326       printf ("  0x%02x ", op);
8327
8328       if ((op & 0xc0) == 0x00)
8329         {
8330           int offset = ((op & 0x3f) << 2) + 4;
8331
8332           printf ("     vsp = vsp + %d", offset);
8333         }
8334       else if ((op & 0xc0) == 0x40)
8335         {
8336           int offset = ((op & 0x3f) << 2) + 4;
8337
8338           printf ("     vsp = vsp - %d", offset);
8339         }
8340       else if ((op & 0xf0) == 0x80)
8341         {
8342           GET_OP (op2);
8343           if (op == 0x80 && op2 == 0)
8344             printf (_("Refuse to unwind"));
8345           else
8346             {
8347               unsigned int mask = ((op & 0x0f) << 8) | op2;
8348               bfd_boolean first = TRUE;
8349               int i;
8350
8351               printf ("pop {");
8352               for (i = 0; i < 12; i++)
8353                 if (mask & (1 << i))
8354                   {
8355                     if (first)
8356                       first = FALSE;
8357                     else
8358                       printf (", ");
8359                     printf ("r%d", 4 + i);
8360                   }
8361               printf ("}");
8362             }
8363         }
8364       else if ((op & 0xf0) == 0x90)
8365         {
8366           if (op == 0x9d || op == 0x9f)
8367             printf (_("     [Reserved]"));
8368           else
8369             printf ("     vsp = r%d", op & 0x0f);
8370         }
8371       else if ((op & 0xf0) == 0xa0)
8372         {
8373           int end = 4 + (op & 0x07);
8374           bfd_boolean first = TRUE;
8375           int i;
8376
8377           printf ("     pop {");
8378           for (i = 4; i <= end; i++)
8379             {
8380               if (first)
8381                 first = FALSE;
8382               else
8383                 printf (", ");
8384               printf ("r%d", i);
8385             }
8386           if (op & 0x08)
8387             {
8388               if (!first)
8389                 printf (", ");
8390               printf ("r14");
8391             }
8392           printf ("}");
8393         }
8394       else if (op == 0xb0)
8395         printf (_("     finish"));
8396       else if (op == 0xb1)
8397         {
8398           GET_OP (op2);
8399           if (op2 == 0 || (op2 & 0xf0) != 0)
8400             printf (_("[Spare]"));
8401           else
8402             {
8403               unsigned int mask = op2 & 0x0f;
8404               bfd_boolean first = TRUE;
8405               int i;
8406
8407               printf ("pop {");
8408               for (i = 0; i < 12; i++)
8409                 if (mask & (1 << i))
8410                   {
8411                     if (first)
8412                       first = FALSE;
8413                     else
8414                       printf (", ");
8415                     printf ("r%d", i);
8416                   }
8417               printf ("}");
8418             }
8419         }
8420       else if (op == 0xb2)
8421         {
8422           unsigned char buf[9];
8423           unsigned int i, len;
8424           unsigned long offset;
8425
8426           for (i = 0; i < sizeof (buf); i++)
8427             {
8428               GET_OP (buf[i]);
8429               if ((buf[i] & 0x80) == 0)
8430                 break;
8431             }
8432           if (i == sizeof (buf))
8433             {
8434               error (_("corrupt change to vsp"));
8435               res = FALSE;
8436             }
8437           else
8438             {
8439               offset = read_uleb128 (buf, &len, buf + i + 1);
8440               assert (len == i + 1);
8441               offset = offset * 4 + 0x204;
8442               printf ("vsp = vsp + %ld", offset);
8443             }
8444         }
8445       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8446         {
8447           unsigned int first, last;
8448
8449           GET_OP (op2);
8450           first = op2 >> 4;
8451           last = op2 & 0x0f;
8452           if (op == 0xc8)
8453             first = first + 16;
8454           printf ("pop {D%d", first);
8455           if (last)
8456             printf ("-D%d", first + last);
8457           printf ("}");
8458         }
8459       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8460         {
8461           unsigned int count = op & 0x07;
8462
8463           printf ("pop {D8");
8464           if (count)
8465             printf ("-D%d", 8 + count);
8466           printf ("}");
8467         }
8468       else if (op >= 0xc0 && op <= 0xc5)
8469         {
8470           unsigned int count = op & 0x07;
8471
8472           printf ("     pop {wR10");
8473           if (count)
8474             printf ("-wR%d", 10 + count);
8475           printf ("}");
8476         }
8477       else if (op == 0xc6)
8478         {
8479           unsigned int first, last;
8480
8481           GET_OP (op2);
8482           first = op2 >> 4;
8483           last = op2 & 0x0f;
8484           printf ("pop {wR%d", first);
8485           if (last)
8486             printf ("-wR%d", first + last);
8487           printf ("}");
8488         }
8489       else if (op == 0xc7)
8490         {
8491           GET_OP (op2);
8492           if (op2 == 0 || (op2 & 0xf0) != 0)
8493             printf (_("[Spare]"));
8494           else
8495             {
8496               unsigned int mask = op2 & 0x0f;
8497               bfd_boolean first = TRUE;
8498               int i;
8499
8500               printf ("pop {");
8501               for (i = 0; i < 4; i++)
8502                 if (mask & (1 << i))
8503                   {
8504                     if (first)
8505                       first = FALSE;
8506                     else
8507                       printf (", ");
8508                     printf ("wCGR%d", i);
8509                   }
8510               printf ("}");
8511             }
8512         }
8513       else
8514         {
8515           printf (_("     [unsupported opcode]"));
8516           res = FALSE;
8517         }
8518
8519       printf ("\n");
8520     }
8521
8522   return res;
8523 }
8524
8525 static bfd_boolean
8526 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8527                               unsigned int               word,
8528                               unsigned int               remaining,
8529                               unsigned int               more_words,
8530                               bfd_vma                    data_offset,
8531                               Elf_Internal_Shdr *        data_sec,
8532                               struct arm_section *       data_arm_sec)
8533 {
8534   struct absaddr addr;
8535
8536   /* Decode the unwinding instructions.  */
8537   while (1)
8538     {
8539       unsigned int op, op2;
8540
8541       ADVANCE;
8542       if (remaining == 0)
8543         break;
8544       remaining--;
8545       op = word >> 24;
8546       word <<= 8;
8547
8548       printf ("  0x%02x ", op);
8549
8550       if ((op & 0xc0) == 0x00)
8551         {
8552           int offset = ((op & 0x3f) << 3) + 8;
8553           printf ("     sp = sp + %d", offset);
8554         }
8555       else if ((op & 0xc0) == 0x80)
8556         {
8557           GET_OP (op2);
8558           if (op == 0x80 && op2 == 0)
8559             printf (_("Refuse to unwind"));
8560           else
8561             {
8562               unsigned int mask = ((op & 0x1f) << 8) | op2;
8563               if (op & 0x20)
8564                 printf ("pop compact {");
8565               else
8566                 printf ("pop {");
8567
8568               decode_tic6x_unwind_regmask (mask);
8569               printf("}");
8570             }
8571         }
8572       else if ((op & 0xf0) == 0xc0)
8573         {
8574           unsigned int reg;
8575           unsigned int nregs;
8576           unsigned int i;
8577           const char *name;
8578           struct
8579           {
8580             unsigned int offset;
8581             unsigned int reg;
8582           } regpos[16];
8583
8584           /* Scan entire instruction first so that GET_OP output is not
8585              interleaved with disassembly.  */
8586           nregs = 0;
8587           for (i = 0; nregs < (op & 0xf); i++)
8588             {
8589               GET_OP (op2);
8590               reg = op2 >> 4;
8591               if (reg != 0xf)
8592                 {
8593                   regpos[nregs].offset = i * 2;
8594                   regpos[nregs].reg = reg;
8595                   nregs++;
8596                 }
8597
8598               reg = op2 & 0xf;
8599               if (reg != 0xf)
8600                 {
8601                   regpos[nregs].offset = i * 2 + 1;
8602                   regpos[nregs].reg = reg;
8603                   nregs++;
8604                 }
8605             }
8606
8607           printf (_("pop frame {"));
8608           reg = nregs - 1;
8609           for (i = i * 2; i > 0; i--)
8610             {
8611               if (regpos[reg].offset == i - 1)
8612                 {
8613                   name = tic6x_unwind_regnames[regpos[reg].reg];
8614                   if (reg > 0)
8615                     reg--;
8616                 }
8617               else
8618                 name = _("[pad]");
8619
8620               fputs (name, stdout);
8621               if (i > 1)
8622                 printf (", ");
8623             }
8624
8625           printf ("}");
8626         }
8627       else if (op == 0xd0)
8628         printf ("     MOV FP, SP");
8629       else if (op == 0xd1)
8630         printf ("     __c6xabi_pop_rts");
8631       else if (op == 0xd2)
8632         {
8633           unsigned char buf[9];
8634           unsigned int i, len;
8635           unsigned long offset;
8636
8637           for (i = 0; i < sizeof (buf); i++)
8638             {
8639               GET_OP (buf[i]);
8640               if ((buf[i] & 0x80) == 0)
8641                 break;
8642             }
8643           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8644           if (i == sizeof (buf))
8645             {
8646               warn (_("Corrupt stack pointer adjustment detected\n"));
8647               return FALSE;
8648             }
8649
8650           offset = read_uleb128 (buf, &len, buf + i + 1);
8651           assert (len == i + 1);
8652           offset = offset * 8 + 0x408;
8653           printf (_("sp = sp + %ld"), offset);
8654         }
8655       else if ((op & 0xf0) == 0xe0)
8656         {
8657           if ((op & 0x0f) == 7)
8658             printf ("     RETURN");
8659           else
8660             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8661         }
8662       else
8663         {
8664           printf (_("     [unsupported opcode]"));
8665         }
8666       putchar ('\n');
8667     }
8668
8669   return TRUE;
8670 }
8671
8672 static bfd_vma
8673 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8674 {
8675   bfd_vma offset;
8676
8677   offset = word & 0x7fffffff;
8678   if (offset & 0x40000000)
8679     offset |= ~ (bfd_vma) 0x7fffffff;
8680
8681   if (elf_header.e_machine == EM_TI_C6000)
8682     offset <<= 1;
8683
8684   return offset + where;
8685 }
8686
8687 static bfd_boolean
8688 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8689                    unsigned int               word,
8690                    unsigned int               remaining,
8691                    bfd_vma                    data_offset,
8692                    Elf_Internal_Shdr *        data_sec,
8693                    struct arm_section *       data_arm_sec)
8694 {
8695   int per_index;
8696   unsigned int more_words = 0;
8697   struct absaddr addr;
8698   bfd_vma sym_name = (bfd_vma) -1;
8699   bfd_boolean res = FALSE;
8700
8701   if (remaining == 0)
8702     {
8703       /* Fetch the first word.
8704          Note - when decoding an object file the address extracted
8705          here will always be 0.  So we also pass in the sym_name
8706          parameter so that we can find the symbol associated with
8707          the personality routine.  */
8708       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8709                                      & word, & addr, & sym_name))
8710         return FALSE;
8711
8712       remaining = 4;
8713     }
8714
8715   if ((word & 0x80000000) == 0)
8716     {
8717       /* Expand prel31 for personality routine.  */
8718       bfd_vma fn;
8719       const char *procname;
8720
8721       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8722       printf (_("  Personality routine: "));
8723       if (fn == 0
8724           && addr.section == SHN_UNDEF && addr.offset == 0
8725           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8726         {
8727           procname = aux->strtab + sym_name;
8728           print_vma (fn, PREFIX_HEX);
8729           if (procname)
8730             {
8731               fputs (" <", stdout);
8732               fputs (procname, stdout);
8733               fputc ('>', stdout);
8734             }
8735         }
8736       else
8737         procname = arm_print_vma_and_name (aux, fn, addr);
8738       fputc ('\n', stdout);
8739
8740       /* The GCC personality routines use the standard compact
8741          encoding, starting with one byte giving the number of
8742          words.  */
8743       if (procname != NULL
8744           && (const_strneq (procname, "__gcc_personality_v0")
8745               || const_strneq (procname, "__gxx_personality_v0")
8746               || const_strneq (procname, "__gcj_personality_v0")
8747               || const_strneq (procname, "__gnu_objc_personality_v0")))
8748         {
8749           remaining = 0;
8750           more_words = 1;
8751           ADVANCE;
8752           if (!remaining)
8753             {
8754               printf (_("  [Truncated data]\n"));
8755               return FALSE;
8756             }
8757           more_words = word >> 24;
8758           word <<= 8;
8759           remaining--;
8760           per_index = -1;
8761         }
8762       else
8763         return TRUE;
8764     }
8765   else
8766     {
8767       /* ARM EHABI Section 6.3:
8768
8769          An exception-handling table entry for the compact model looks like:
8770
8771            31 30-28 27-24 23-0
8772            -- ----- ----- ----
8773             1   0   index Data for personalityRoutine[index]    */
8774
8775       if (elf_header.e_machine == EM_ARM
8776           && (word & 0x70000000))
8777         {
8778           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8779           res = FALSE;
8780         }
8781
8782       per_index = (word >> 24) & 0x7f;
8783       printf (_("  Compact model index: %d\n"), per_index);
8784       if (per_index == 0)
8785         {
8786           more_words = 0;
8787           word <<= 8;
8788           remaining--;
8789         }
8790       else if (per_index < 3)
8791         {
8792           more_words = (word >> 16) & 0xff;
8793           word <<= 16;
8794           remaining -= 2;
8795         }
8796     }
8797
8798   switch (elf_header.e_machine)
8799     {
8800     case EM_ARM:
8801       if (per_index < 3)
8802         {
8803           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8804                                             data_offset, data_sec, data_arm_sec))
8805             res = FALSE;
8806         }
8807       else
8808         {
8809           warn (_("Unknown ARM compact model index encountered\n"));
8810           printf (_("  [reserved]\n"));
8811           res = FALSE;
8812         }
8813       break;
8814
8815     case EM_TI_C6000:
8816       if (per_index < 3)
8817         {
8818           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8819                                               data_offset, data_sec, data_arm_sec))
8820             res = FALSE;
8821         }
8822       else if (per_index < 5)
8823         {
8824           if (((word >> 17) & 0x7f) == 0x7f)
8825             printf (_("  Restore stack from frame pointer\n"));
8826           else
8827             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8828           printf (_("  Registers restored: "));
8829           if (per_index == 4)
8830             printf (" (compact) ");
8831           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8832           putchar ('\n');
8833           printf (_("  Return register: %s\n"),
8834                   tic6x_unwind_regnames[word & 0xf]);
8835         }
8836       else
8837         printf (_("  [reserved (%d)]\n"), per_index);
8838       break;
8839
8840     default:
8841       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8842              elf_header.e_machine);
8843       res = FALSE;
8844     }
8845
8846   /* Decode the descriptors.  Not implemented.  */
8847
8848   return res;
8849 }
8850
8851 static bfd_boolean
8852 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8853 {
8854   struct arm_section exidx_arm_sec, extab_arm_sec;
8855   unsigned int i, exidx_len;
8856   unsigned long j, nfuns;
8857   bfd_boolean res = TRUE;
8858
8859   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8860   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8861   exidx_len = exidx_sec->sh_size / 8;
8862
8863   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8864   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8865     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8866       aux->funtab[nfuns++] = aux->symtab[j];
8867   aux->nfuns = nfuns;
8868   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8869
8870   for (i = 0; i < exidx_len; i++)
8871     {
8872       unsigned int exidx_fn, exidx_entry;
8873       struct absaddr fn_addr, entry_addr;
8874       bfd_vma fn;
8875
8876       fputc ('\n', stdout);
8877
8878       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8879                                      8 * i, & exidx_fn, & fn_addr, NULL)
8880           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8881                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8882         {
8883           free (aux->funtab);
8884           arm_free_section (& exidx_arm_sec);
8885           arm_free_section (& extab_arm_sec);
8886           return FALSE;
8887         }
8888
8889       /* ARM EHABI, Section 5:
8890          An index table entry consists of 2 words.
8891          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8892       if (exidx_fn & 0x80000000)
8893         {
8894           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8895           res = FALSE;
8896         }
8897
8898       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8899
8900       arm_print_vma_and_name (aux, fn, fn_addr);
8901       fputs (": ", stdout);
8902
8903       if (exidx_entry == 1)
8904         {
8905           print_vma (exidx_entry, PREFIX_HEX);
8906           fputs (" [cantunwind]\n", stdout);
8907         }
8908       else if (exidx_entry & 0x80000000)
8909         {
8910           print_vma (exidx_entry, PREFIX_HEX);
8911           fputc ('\n', stdout);
8912           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8913         }
8914       else
8915         {
8916           bfd_vma table, table_offset = 0;
8917           Elf_Internal_Shdr *table_sec;
8918
8919           fputs ("@", stdout);
8920           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8921           print_vma (table, PREFIX_HEX);
8922           printf ("\n");
8923
8924           /* Locate the matching .ARM.extab.  */
8925           if (entry_addr.section != SHN_UNDEF
8926               && entry_addr.section < elf_header.e_shnum)
8927             {
8928               table_sec = section_headers + entry_addr.section;
8929               table_offset = entry_addr.offset;
8930               /* PR 18879 */
8931               if (table_offset > table_sec->sh_size
8932                   || ((bfd_signed_vma) table_offset) < 0)
8933                 {
8934                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8935                         (unsigned long) table_offset,
8936                         printable_section_name (table_sec));
8937                   res = FALSE;
8938                   continue;
8939                 }
8940             }
8941           else
8942             {
8943               table_sec = find_section_by_address (table);
8944               if (table_sec != NULL)
8945                 table_offset = table - table_sec->sh_addr;
8946             }
8947
8948           if (table_sec == NULL)
8949             {
8950               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8951                     (unsigned long) table);
8952               res = FALSE;
8953               continue;
8954             }
8955
8956           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8957                                    &extab_arm_sec))
8958             res = FALSE;
8959         }
8960     }
8961
8962   printf ("\n");
8963
8964   free (aux->funtab);
8965   arm_free_section (&exidx_arm_sec);
8966   arm_free_section (&extab_arm_sec);
8967
8968   return res;
8969 }
8970
8971 /* Used for both ARM and C6X unwinding tables.  */
8972
8973 static bfd_boolean
8974 arm_process_unwind (FILE *file)
8975 {
8976   struct arm_unw_aux_info aux;
8977   Elf_Internal_Shdr *unwsec = NULL;
8978   Elf_Internal_Shdr *strsec;
8979   Elf_Internal_Shdr *sec;
8980   unsigned long i;
8981   unsigned int sec_type;
8982   bfd_boolean res = TRUE;
8983
8984   switch (elf_header.e_machine)
8985     {
8986     case EM_ARM:
8987       sec_type = SHT_ARM_EXIDX;
8988       break;
8989
8990     case EM_TI_C6000:
8991       sec_type = SHT_C6000_UNWIND;
8992       break;
8993
8994     default:
8995       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8996              elf_header.e_machine);
8997       return FALSE;
8998     }
8999
9000   if (string_table == NULL)
9001     return FALSE;
9002
9003   memset (& aux, 0, sizeof (aux));
9004   aux.file = file;
9005
9006   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9007     {
9008       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9009         {
9010           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9011
9012           strsec = section_headers + sec->sh_link;
9013
9014           /* PR binutils/17531 file: 011-12666-0.004.  */
9015           if (aux.strtab != NULL)
9016             {
9017               error (_("Multiple string tables found in file.\n"));
9018               free (aux.strtab);
9019               res = FALSE;
9020             }
9021           aux.strtab = get_data (NULL, file, strsec->sh_offset,
9022                                  1, strsec->sh_size, _("string table"));
9023           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9024         }
9025       else if (sec->sh_type == sec_type)
9026         unwsec = sec;
9027     }
9028
9029   if (unwsec == NULL)
9030     printf (_("\nThere are no unwind sections in this file.\n"));
9031   else
9032     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9033       {
9034         if (sec->sh_type == sec_type)
9035           {
9036             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9037                     printable_section_name (sec),
9038                     (unsigned long) sec->sh_offset,
9039                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9040
9041             if (! dump_arm_unwind (&aux, sec))
9042               res = FALSE;
9043           }
9044       }
9045
9046   if (aux.symtab)
9047     free (aux.symtab);
9048   if (aux.strtab)
9049     free ((char *) aux.strtab);
9050
9051   return res;
9052 }
9053
9054 static bfd_boolean
9055 process_unwind (FILE * file)
9056 {
9057   struct unwind_handler
9058   {
9059     unsigned int machtype;
9060     bfd_boolean (* handler)(FILE *);
9061   } handlers[] =
9062   {
9063     { EM_ARM, arm_process_unwind },
9064     { EM_IA_64, ia64_process_unwind },
9065     { EM_PARISC, hppa_process_unwind },
9066     { EM_TI_C6000, arm_process_unwind },
9067     { 0, NULL }
9068   };
9069   int i;
9070
9071   if (!do_unwind)
9072     return TRUE;
9073
9074   for (i = 0; handlers[i].handler != NULL; i++)
9075     if (elf_header.e_machine == handlers[i].machtype)
9076       return handlers[i].handler (file);
9077
9078   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9079           get_machine_name (elf_header.e_machine));
9080   return TRUE;
9081 }
9082
9083 static void
9084 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9085 {
9086   switch (entry->d_tag)
9087     {
9088     case DT_MIPS_FLAGS:
9089       if (entry->d_un.d_val == 0)
9090         printf (_("NONE"));
9091       else
9092         {
9093           static const char * opts[] =
9094           {
9095             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9096             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9097             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9098             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9099             "RLD_ORDER_SAFE"
9100           };
9101           unsigned int cnt;
9102           bfd_boolean first = TRUE;
9103
9104           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9105             if (entry->d_un.d_val & (1 << cnt))
9106               {
9107                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9108                 first = FALSE;
9109               }
9110         }
9111       break;
9112
9113     case DT_MIPS_IVERSION:
9114       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9115         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9116       else
9117         {
9118           char buf[40];
9119           sprintf_vma (buf, entry->d_un.d_ptr);
9120           /* Note: coded this way so that there is a single string for translation.  */
9121           printf (_("<corrupt: %s>"), buf);
9122         }
9123       break;
9124
9125     case DT_MIPS_TIME_STAMP:
9126       {
9127         char timebuf[128];
9128         struct tm * tmp;
9129         time_t atime = entry->d_un.d_val;
9130
9131         tmp = gmtime (&atime);
9132         /* PR 17531: file: 6accc532.  */
9133         if (tmp == NULL)
9134           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9135         else
9136           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9137                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9138                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9139         printf (_("Time Stamp: %s"), timebuf);
9140       }
9141       break;
9142
9143     case DT_MIPS_RLD_VERSION:
9144     case DT_MIPS_LOCAL_GOTNO:
9145     case DT_MIPS_CONFLICTNO:
9146     case DT_MIPS_LIBLISTNO:
9147     case DT_MIPS_SYMTABNO:
9148     case DT_MIPS_UNREFEXTNO:
9149     case DT_MIPS_HIPAGENO:
9150     case DT_MIPS_DELTA_CLASS_NO:
9151     case DT_MIPS_DELTA_INSTANCE_NO:
9152     case DT_MIPS_DELTA_RELOC_NO:
9153     case DT_MIPS_DELTA_SYM_NO:
9154     case DT_MIPS_DELTA_CLASSSYM_NO:
9155     case DT_MIPS_COMPACT_SIZE:
9156       print_vma (entry->d_un.d_val, DEC);
9157       break;
9158
9159     default:
9160       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9161     }
9162     putchar ('\n');
9163 }
9164
9165 static void
9166 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9167 {
9168   switch (entry->d_tag)
9169     {
9170     case DT_HP_DLD_FLAGS:
9171       {
9172         static struct
9173         {
9174           long int bit;
9175           const char * str;
9176         }
9177         flags[] =
9178         {
9179           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9180           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9181           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9182           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9183           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9184           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9185           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9186           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9187           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9188           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9189           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9190           { DT_HP_GST, "HP_GST" },
9191           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9192           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9193           { DT_HP_NODELETE, "HP_NODELETE" },
9194           { DT_HP_GROUP, "HP_GROUP" },
9195           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9196         };
9197         bfd_boolean first = TRUE;
9198         size_t cnt;
9199         bfd_vma val = entry->d_un.d_val;
9200
9201         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9202           if (val & flags[cnt].bit)
9203             {
9204               if (! first)
9205                 putchar (' ');
9206               fputs (flags[cnt].str, stdout);
9207               first = FALSE;
9208               val ^= flags[cnt].bit;
9209             }
9210
9211         if (val != 0 || first)
9212           {
9213             if (! first)
9214               putchar (' ');
9215             print_vma (val, HEX);
9216           }
9217       }
9218       break;
9219
9220     default:
9221       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9222       break;
9223     }
9224   putchar ('\n');
9225 }
9226
9227 #ifdef BFD64
9228
9229 /* VMS vs Unix time offset and factor.  */
9230
9231 #define VMS_EPOCH_OFFSET 35067168000000000LL
9232 #define VMS_GRANULARITY_FACTOR 10000000
9233
9234 /* Display a VMS time in a human readable format.  */
9235
9236 static void
9237 print_vms_time (bfd_int64_t vmstime)
9238 {
9239   struct tm *tm;
9240   time_t unxtime;
9241
9242   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9243   tm = gmtime (&unxtime);
9244   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9245           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9246           tm->tm_hour, tm->tm_min, tm->tm_sec);
9247 }
9248 #endif /* BFD64 */
9249
9250 static void
9251 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9252 {
9253   switch (entry->d_tag)
9254     {
9255     case DT_IA_64_PLT_RESERVE:
9256       /* First 3 slots reserved.  */
9257       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9258       printf (" -- ");
9259       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9260       break;
9261
9262     case DT_IA_64_VMS_LINKTIME:
9263 #ifdef BFD64
9264       print_vms_time (entry->d_un.d_val);
9265 #endif
9266       break;
9267
9268     case DT_IA_64_VMS_LNKFLAGS:
9269       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9270       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9271         printf (" CALL_DEBUG");
9272       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9273         printf (" NOP0BUFS");
9274       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9275         printf (" P0IMAGE");
9276       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9277         printf (" MKTHREADS");
9278       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9279         printf (" UPCALLS");
9280       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9281         printf (" IMGSTA");
9282       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9283         printf (" INITIALIZE");
9284       if (entry->d_un.d_val & VMS_LF_MAIN)
9285         printf (" MAIN");
9286       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9287         printf (" EXE_INIT");
9288       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9289         printf (" TBK_IN_IMG");
9290       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9291         printf (" DBG_IN_IMG");
9292       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9293         printf (" TBK_IN_DSF");
9294       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9295         printf (" DBG_IN_DSF");
9296       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9297         printf (" SIGNATURES");
9298       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9299         printf (" REL_SEG_OFF");
9300       break;
9301
9302     default:
9303       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9304       break;
9305     }
9306   putchar ('\n');
9307 }
9308
9309 static bfd_boolean
9310 get_32bit_dynamic_section (FILE * file)
9311 {
9312   Elf32_External_Dyn * edyn;
9313   Elf32_External_Dyn * ext;
9314   Elf_Internal_Dyn * entry;
9315
9316   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9317                                           dynamic_size, _("dynamic section"));
9318   if (!edyn)
9319     return FALSE;
9320
9321   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9322      might not have the luxury of section headers.  Look for the DT_NULL
9323      terminator to determine the number of entries.  */
9324   for (ext = edyn, dynamic_nent = 0;
9325        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9326        ext++)
9327     {
9328       dynamic_nent++;
9329       if (BYTE_GET (ext->d_tag) == DT_NULL)
9330         break;
9331     }
9332
9333   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9334                                                   sizeof (* entry));
9335   if (dynamic_section == NULL)
9336     {
9337       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9338              (unsigned long) dynamic_nent);
9339       free (edyn);
9340       return FALSE;
9341     }
9342
9343   for (ext = edyn, entry = dynamic_section;
9344        entry < dynamic_section + dynamic_nent;
9345        ext++, entry++)
9346     {
9347       entry->d_tag      = BYTE_GET (ext->d_tag);
9348       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9349     }
9350
9351   free (edyn);
9352
9353   return TRUE;
9354 }
9355
9356 static bfd_boolean
9357 get_64bit_dynamic_section (FILE * file)
9358 {
9359   Elf64_External_Dyn * edyn;
9360   Elf64_External_Dyn * ext;
9361   Elf_Internal_Dyn * entry;
9362
9363   /* Read in the data.  */
9364   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9365                                           dynamic_size, _("dynamic section"));
9366   if (!edyn)
9367     return FALSE;
9368
9369   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9370      might not have the luxury of section headers.  Look for the DT_NULL
9371      terminator to determine the number of entries.  */
9372   for (ext = edyn, dynamic_nent = 0;
9373        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9374        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9375        ext++)
9376     {
9377       dynamic_nent++;
9378       if (BYTE_GET (ext->d_tag) == DT_NULL)
9379         break;
9380     }
9381
9382   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9383                                                   sizeof (* entry));
9384   if (dynamic_section == NULL)
9385     {
9386       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387              (unsigned long) dynamic_nent);
9388       free (edyn);
9389       return FALSE;
9390     }
9391
9392   /* Convert from external to internal formats.  */
9393   for (ext = edyn, entry = dynamic_section;
9394        entry < dynamic_section + dynamic_nent;
9395        ext++, entry++)
9396     {
9397       entry->d_tag      = BYTE_GET (ext->d_tag);
9398       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9399     }
9400
9401   free (edyn);
9402
9403   return TRUE;
9404 }
9405
9406 static void
9407 print_dynamic_flags (bfd_vma flags)
9408 {
9409   bfd_boolean first = TRUE;
9410
9411   while (flags)
9412     {
9413       bfd_vma flag;
9414
9415       flag = flags & - flags;
9416       flags &= ~ flag;
9417
9418       if (first)
9419         first = FALSE;
9420       else
9421         putc (' ', stdout);
9422
9423       switch (flag)
9424         {
9425         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9426         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9427         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9428         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9429         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9430         default:                fputs (_("unknown"), stdout); break;
9431         }
9432     }
9433   puts ("");
9434 }
9435
9436 /* Parse and display the contents of the dynamic section.  */
9437
9438 static bfd_boolean
9439 process_dynamic_section (FILE * file)
9440 {
9441   Elf_Internal_Dyn * entry;
9442
9443   if (dynamic_size == 0)
9444     {
9445       if (do_dynamic)
9446         printf (_("\nThere is no dynamic section in this file.\n"));
9447
9448       return TRUE;
9449     }
9450
9451   if (is_32bit_elf)
9452     {
9453       if (! get_32bit_dynamic_section (file))
9454         return FALSE;
9455     }
9456   else
9457     {
9458       if (! get_64bit_dynamic_section (file))
9459         return FALSE;
9460     }
9461
9462   /* Find the appropriate symbol table.  */
9463   if (dynamic_symbols == NULL)
9464     {
9465       for (entry = dynamic_section;
9466            entry < dynamic_section + dynamic_nent;
9467            ++entry)
9468         {
9469           Elf_Internal_Shdr section;
9470
9471           if (entry->d_tag != DT_SYMTAB)
9472             continue;
9473
9474           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9475
9476           /* Since we do not know how big the symbol table is,
9477              we default to reading in the entire file (!) and
9478              processing that.  This is overkill, I know, but it
9479              should work.  */
9480           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9481           if ((bfd_size_type) section.sh_offset > current_file_size)
9482             {
9483               /* See PR 21379 for a reproducer.  */
9484               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9485               return FALSE;
9486             }
9487
9488           if (archive_file_offset != 0)
9489             section.sh_size = archive_file_size - section.sh_offset;
9490           else
9491             {
9492               if (fseek (file, 0, SEEK_END))
9493                 error (_("Unable to seek to end of file!\n"));
9494
9495               section.sh_size = ftell (file) - section.sh_offset;
9496             }
9497
9498           if (is_32bit_elf)
9499             section.sh_entsize = sizeof (Elf32_External_Sym);
9500           else
9501             section.sh_entsize = sizeof (Elf64_External_Sym);
9502           section.sh_name = string_table_length;
9503
9504           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9505           if (num_dynamic_syms < 1)
9506             {
9507               error (_("Unable to determine the number of symbols to load\n"));
9508               continue;
9509             }
9510         }
9511     }
9512
9513   /* Similarly find a string table.  */
9514   if (dynamic_strings == NULL)
9515     {
9516       for (entry = dynamic_section;
9517            entry < dynamic_section + dynamic_nent;
9518            ++entry)
9519         {
9520           unsigned long offset;
9521           long str_tab_len;
9522
9523           if (entry->d_tag != DT_STRTAB)
9524             continue;
9525
9526           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9527
9528           /* Since we do not know how big the string table is,
9529              we default to reading in the entire file (!) and
9530              processing that.  This is overkill, I know, but it
9531              should work.  */
9532
9533           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9534
9535           if (archive_file_offset != 0)
9536             str_tab_len = archive_file_size - offset;
9537           else
9538             {
9539               if (fseek (file, 0, SEEK_END))
9540                 error (_("Unable to seek to end of file\n"));
9541               str_tab_len = ftell (file) - offset;
9542             }
9543
9544           if (str_tab_len < 1)
9545             {
9546               error
9547                 (_("Unable to determine the length of the dynamic string table\n"));
9548               continue;
9549             }
9550
9551           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9552                                                str_tab_len,
9553                                                _("dynamic string table"));
9554           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9555           break;
9556         }
9557     }
9558
9559   /* And find the syminfo section if available.  */
9560   if (dynamic_syminfo == NULL)
9561     {
9562       unsigned long syminsz = 0;
9563
9564       for (entry = dynamic_section;
9565            entry < dynamic_section + dynamic_nent;
9566            ++entry)
9567         {
9568           if (entry->d_tag == DT_SYMINENT)
9569             {
9570               /* Note: these braces are necessary to avoid a syntax
9571                  error from the SunOS4 C compiler.  */
9572               /* PR binutils/17531: A corrupt file can trigger this test.
9573                  So do not use an assert, instead generate an error message.  */
9574               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9575                 error (_("Bad value (%d) for SYMINENT entry\n"),
9576                        (int) entry->d_un.d_val);
9577             }
9578           else if (entry->d_tag == DT_SYMINSZ)
9579             syminsz = entry->d_un.d_val;
9580           else if (entry->d_tag == DT_SYMINFO)
9581             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9582                                                       syminsz);
9583         }
9584
9585       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9586         {
9587           Elf_External_Syminfo * extsyminfo;
9588           Elf_External_Syminfo * extsym;
9589           Elf_Internal_Syminfo * syminfo;
9590
9591           /* There is a syminfo section.  Read the data.  */
9592           extsyminfo = (Elf_External_Syminfo *)
9593               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9594                         _("symbol information"));
9595           if (!extsyminfo)
9596             return FALSE;
9597
9598           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9599           if (dynamic_syminfo == NULL)
9600             {
9601               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9602                      (unsigned long) syminsz);
9603               return FALSE;
9604             }
9605
9606           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9607           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9608                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9609                ++syminfo, ++extsym)
9610             {
9611               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9612               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9613             }
9614
9615           free (extsyminfo);
9616         }
9617     }
9618
9619   if (do_dynamic && dynamic_addr)
9620     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9621             dynamic_addr, (unsigned long) dynamic_nent);
9622   if (do_dynamic)
9623     printf (_("  Tag        Type                         Name/Value\n"));
9624
9625   for (entry = dynamic_section;
9626        entry < dynamic_section + dynamic_nent;
9627        entry++)
9628     {
9629       if (do_dynamic)
9630         {
9631           const char * dtype;
9632
9633           putchar (' ');
9634           print_vma (entry->d_tag, FULL_HEX);
9635           dtype = get_dynamic_type (entry->d_tag);
9636           printf (" (%s)%*s", dtype,
9637                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9638         }
9639
9640       switch (entry->d_tag)
9641         {
9642         case DT_FLAGS:
9643           if (do_dynamic)
9644             print_dynamic_flags (entry->d_un.d_val);
9645           break;
9646
9647         case DT_AUXILIARY:
9648         case DT_FILTER:
9649         case DT_CONFIG:
9650         case DT_DEPAUDIT:
9651         case DT_AUDIT:
9652           if (do_dynamic)
9653             {
9654               switch (entry->d_tag)
9655                 {
9656                 case DT_AUXILIARY:
9657                   printf (_("Auxiliary library"));
9658                   break;
9659
9660                 case DT_FILTER:
9661                   printf (_("Filter library"));
9662                   break;
9663
9664                 case DT_CONFIG:
9665                   printf (_("Configuration file"));
9666                   break;
9667
9668                 case DT_DEPAUDIT:
9669                   printf (_("Dependency audit library"));
9670                   break;
9671
9672                 case DT_AUDIT:
9673                   printf (_("Audit library"));
9674                   break;
9675                 }
9676
9677               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9678                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9679               else
9680                 {
9681                   printf (": ");
9682                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9683                   putchar ('\n');
9684                 }
9685             }
9686           break;
9687
9688         case DT_FEATURE:
9689           if (do_dynamic)
9690             {
9691               printf (_("Flags:"));
9692
9693               if (entry->d_un.d_val == 0)
9694                 printf (_(" None\n"));
9695               else
9696                 {
9697                   unsigned long int val = entry->d_un.d_val;
9698
9699                   if (val & DTF_1_PARINIT)
9700                     {
9701                       printf (" PARINIT");
9702                       val ^= DTF_1_PARINIT;
9703                     }
9704                   if (val & DTF_1_CONFEXP)
9705                     {
9706                       printf (" CONFEXP");
9707                       val ^= DTF_1_CONFEXP;
9708                     }
9709                   if (val != 0)
9710                     printf (" %lx", val);
9711                   puts ("");
9712                 }
9713             }
9714           break;
9715
9716         case DT_POSFLAG_1:
9717           if (do_dynamic)
9718             {
9719               printf (_("Flags:"));
9720
9721               if (entry->d_un.d_val == 0)
9722                 printf (_(" None\n"));
9723               else
9724                 {
9725                   unsigned long int val = entry->d_un.d_val;
9726
9727                   if (val & DF_P1_LAZYLOAD)
9728                     {
9729                       printf (" LAZYLOAD");
9730                       val ^= DF_P1_LAZYLOAD;
9731                     }
9732                   if (val & DF_P1_GROUPPERM)
9733                     {
9734                       printf (" GROUPPERM");
9735                       val ^= DF_P1_GROUPPERM;
9736                     }
9737                   if (val != 0)
9738                     printf (" %lx", val);
9739                   puts ("");
9740                 }
9741             }
9742           break;
9743
9744         case DT_FLAGS_1:
9745           if (do_dynamic)
9746             {
9747               printf (_("Flags:"));
9748               if (entry->d_un.d_val == 0)
9749                 printf (_(" None\n"));
9750               else
9751                 {
9752                   unsigned long int val = entry->d_un.d_val;
9753
9754                   if (val & DF_1_NOW)
9755                     {
9756                       printf (" NOW");
9757                       val ^= DF_1_NOW;
9758                     }
9759                   if (val & DF_1_GLOBAL)
9760                     {
9761                       printf (" GLOBAL");
9762                       val ^= DF_1_GLOBAL;
9763                     }
9764                   if (val & DF_1_GROUP)
9765                     {
9766                       printf (" GROUP");
9767                       val ^= DF_1_GROUP;
9768                     }
9769                   if (val & DF_1_NODELETE)
9770                     {
9771                       printf (" NODELETE");
9772                       val ^= DF_1_NODELETE;
9773                     }
9774                   if (val & DF_1_LOADFLTR)
9775                     {
9776                       printf (" LOADFLTR");
9777                       val ^= DF_1_LOADFLTR;
9778                     }
9779                   if (val & DF_1_INITFIRST)
9780                     {
9781                       printf (" INITFIRST");
9782                       val ^= DF_1_INITFIRST;
9783                     }
9784                   if (val & DF_1_NOOPEN)
9785                     {
9786                       printf (" NOOPEN");
9787                       val ^= DF_1_NOOPEN;
9788                     }
9789                   if (val & DF_1_ORIGIN)
9790                     {
9791                       printf (" ORIGIN");
9792                       val ^= DF_1_ORIGIN;
9793                     }
9794                   if (val & DF_1_DIRECT)
9795                     {
9796                       printf (" DIRECT");
9797                       val ^= DF_1_DIRECT;
9798                     }
9799                   if (val & DF_1_TRANS)
9800                     {
9801                       printf (" TRANS");
9802                       val ^= DF_1_TRANS;
9803                     }
9804                   if (val & DF_1_INTERPOSE)
9805                     {
9806                       printf (" INTERPOSE");
9807                       val ^= DF_1_INTERPOSE;
9808                     }
9809                   if (val & DF_1_NODEFLIB)
9810                     {
9811                       printf (" NODEFLIB");
9812                       val ^= DF_1_NODEFLIB;
9813                     }
9814                   if (val & DF_1_NODUMP)
9815                     {
9816                       printf (" NODUMP");
9817                       val ^= DF_1_NODUMP;
9818                     }
9819                   if (val & DF_1_CONFALT)
9820                     {
9821                       printf (" CONFALT");
9822                       val ^= DF_1_CONFALT;
9823                     }
9824                   if (val & DF_1_ENDFILTEE)
9825                     {
9826                       printf (" ENDFILTEE");
9827                       val ^= DF_1_ENDFILTEE;
9828                     }
9829                   if (val & DF_1_DISPRELDNE)
9830                     {
9831                       printf (" DISPRELDNE");
9832                       val ^= DF_1_DISPRELDNE;
9833                     }
9834                   if (val & DF_1_DISPRELPND)
9835                     {
9836                       printf (" DISPRELPND");
9837                       val ^= DF_1_DISPRELPND;
9838                     }
9839                   if (val & DF_1_NODIRECT)
9840                     {
9841                       printf (" NODIRECT");
9842                       val ^= DF_1_NODIRECT;
9843                     }
9844                   if (val & DF_1_IGNMULDEF)
9845                     {
9846                       printf (" IGNMULDEF");
9847                       val ^= DF_1_IGNMULDEF;
9848                     }
9849                   if (val & DF_1_NOKSYMS)
9850                     {
9851                       printf (" NOKSYMS");
9852                       val ^= DF_1_NOKSYMS;
9853                     }
9854                   if (val & DF_1_NOHDR)
9855                     {
9856                       printf (" NOHDR");
9857                       val ^= DF_1_NOHDR;
9858                     }
9859                   if (val & DF_1_EDITED)
9860                     {
9861                       printf (" EDITED");
9862                       val ^= DF_1_EDITED;
9863                     }
9864                   if (val & DF_1_NORELOC)
9865                     {
9866                       printf (" NORELOC");
9867                       val ^= DF_1_NORELOC;
9868                     }
9869                   if (val & DF_1_SYMINTPOSE)
9870                     {
9871                       printf (" SYMINTPOSE");
9872                       val ^= DF_1_SYMINTPOSE;
9873                     }
9874                   if (val & DF_1_GLOBAUDIT)
9875                     {
9876                       printf (" GLOBAUDIT");
9877                       val ^= DF_1_GLOBAUDIT;
9878                     }
9879                   if (val & DF_1_SINGLETON)
9880                     {
9881                       printf (" SINGLETON");
9882                       val ^= DF_1_SINGLETON;
9883                     }
9884                   if (val & DF_1_STUB)
9885                     {
9886                       printf (" STUB");
9887                       val ^= DF_1_STUB;
9888                     }
9889                   if (val & DF_1_PIE)
9890                     {
9891                       printf (" PIE");
9892                       val ^= DF_1_PIE;
9893                     }
9894                   if (val != 0)
9895                     printf (" %lx", val);
9896                   puts ("");
9897                 }
9898             }
9899           break;
9900
9901         case DT_PLTREL:
9902           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9903           if (do_dynamic)
9904             puts (get_dynamic_type (entry->d_un.d_val));
9905           break;
9906
9907         case DT_NULL    :
9908         case DT_NEEDED  :
9909         case DT_PLTGOT  :
9910         case DT_HASH    :
9911         case DT_STRTAB  :
9912         case DT_SYMTAB  :
9913         case DT_RELA    :
9914         case DT_INIT    :
9915         case DT_FINI    :
9916         case DT_SONAME  :
9917         case DT_RPATH   :
9918         case DT_SYMBOLIC:
9919         case DT_REL     :
9920         case DT_DEBUG   :
9921         case DT_TEXTREL :
9922         case DT_JMPREL  :
9923         case DT_RUNPATH :
9924           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9925
9926           if (do_dynamic)
9927             {
9928               char * name;
9929
9930               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9931                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9932               else
9933                 name = NULL;
9934
9935               if (name)
9936                 {
9937                   switch (entry->d_tag)
9938                     {
9939                     case DT_NEEDED:
9940                       printf (_("Shared library: [%s]"), name);
9941
9942                       if (streq (name, program_interpreter))
9943                         printf (_(" program interpreter"));
9944                       break;
9945
9946                     case DT_SONAME:
9947                       printf (_("Library soname: [%s]"), name);
9948                       break;
9949
9950                     case DT_RPATH:
9951                       printf (_("Library rpath: [%s]"), name);
9952                       break;
9953
9954                     case DT_RUNPATH:
9955                       printf (_("Library runpath: [%s]"), name);
9956                       break;
9957
9958                     default:
9959                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9960                       break;
9961                     }
9962                 }
9963               else
9964                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9965
9966               putchar ('\n');
9967             }
9968           break;
9969
9970         case DT_PLTRELSZ:
9971         case DT_RELASZ  :
9972         case DT_STRSZ   :
9973         case DT_RELSZ   :
9974         case DT_RELAENT :
9975         case DT_SYMENT  :
9976         case DT_RELENT  :
9977           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9978           /* Fall through.  */
9979         case DT_PLTPADSZ:
9980         case DT_MOVEENT :
9981         case DT_MOVESZ  :
9982         case DT_INIT_ARRAYSZ:
9983         case DT_FINI_ARRAYSZ:
9984         case DT_GNU_CONFLICTSZ:
9985         case DT_GNU_LIBLISTSZ:
9986           if (do_dynamic)
9987             {
9988               print_vma (entry->d_un.d_val, UNSIGNED);
9989               printf (_(" (bytes)\n"));
9990             }
9991           break;
9992
9993         case DT_VERDEFNUM:
9994         case DT_VERNEEDNUM:
9995         case DT_RELACOUNT:
9996         case DT_RELCOUNT:
9997           if (do_dynamic)
9998             {
9999               print_vma (entry->d_un.d_val, UNSIGNED);
10000               putchar ('\n');
10001             }
10002           break;
10003
10004         case DT_SYMINSZ:
10005         case DT_SYMINENT:
10006         case DT_SYMINFO:
10007         case DT_USED:
10008         case DT_INIT_ARRAY:
10009         case DT_FINI_ARRAY:
10010           if (do_dynamic)
10011             {
10012               if (entry->d_tag == DT_USED
10013                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10014                 {
10015                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10016
10017                   if (*name)
10018                     {
10019                       printf (_("Not needed object: [%s]\n"), name);
10020                       break;
10021                     }
10022                 }
10023
10024               print_vma (entry->d_un.d_val, PREFIX_HEX);
10025               putchar ('\n');
10026             }
10027           break;
10028
10029         case DT_BIND_NOW:
10030           /* The value of this entry is ignored.  */
10031           if (do_dynamic)
10032             putchar ('\n');
10033           break;
10034
10035         case DT_GNU_PRELINKED:
10036           if (do_dynamic)
10037             {
10038               struct tm * tmp;
10039               time_t atime = entry->d_un.d_val;
10040
10041               tmp = gmtime (&atime);
10042               /* PR 17533 file: 041-1244816-0.004.  */
10043               if (tmp == NULL)
10044                 printf (_("<corrupt time val: %lx"),
10045                         (unsigned long) atime);
10046               else
10047                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10048                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10049                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10050
10051             }
10052           break;
10053
10054         case DT_GNU_HASH:
10055           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10056           if (do_dynamic)
10057             {
10058               print_vma (entry->d_un.d_val, PREFIX_HEX);
10059               putchar ('\n');
10060             }
10061           break;
10062
10063         default:
10064           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10065             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10066               entry->d_un.d_val;
10067
10068           if (do_dynamic)
10069             {
10070               switch (elf_header.e_machine)
10071                 {
10072                 case EM_MIPS:
10073                 case EM_MIPS_RS3_LE:
10074                   dynamic_section_mips_val (entry);
10075                   break;
10076                 case EM_PARISC:
10077                   dynamic_section_parisc_val (entry);
10078                   break;
10079                 case EM_IA_64:
10080                   dynamic_section_ia64_val (entry);
10081                   break;
10082                 default:
10083                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10084                   putchar ('\n');
10085                 }
10086             }
10087           break;
10088         }
10089     }
10090
10091   return TRUE;
10092 }
10093
10094 static char *
10095 get_ver_flags (unsigned int flags)
10096 {
10097   static char buff[32];
10098
10099   buff[0] = 0;
10100
10101   if (flags == 0)
10102     return _("none");
10103
10104   if (flags & VER_FLG_BASE)
10105     strcat (buff, "BASE");
10106
10107   if (flags & VER_FLG_WEAK)
10108     {
10109       if (flags & VER_FLG_BASE)
10110         strcat (buff, " | ");
10111
10112       strcat (buff, "WEAK");
10113     }
10114
10115   if (flags & VER_FLG_INFO)
10116     {
10117       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10118         strcat (buff, " | ");
10119
10120       strcat (buff, "INFO");
10121     }
10122
10123   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10124     {
10125       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10126         strcat (buff, " | ");
10127
10128       strcat (buff, _("<unknown>"));
10129     }
10130
10131   return buff;
10132 }
10133
10134 /* Display the contents of the version sections.  */
10135
10136 static bfd_boolean
10137 process_version_sections (FILE * file)
10138 {
10139   Elf_Internal_Shdr * section;
10140   unsigned i;
10141   bfd_boolean found = FALSE;
10142
10143   if (! do_version)
10144     return TRUE;
10145
10146   for (i = 0, section = section_headers;
10147        i < elf_header.e_shnum;
10148        i++, section++)
10149     {
10150       switch (section->sh_type)
10151         {
10152         case SHT_GNU_verdef:
10153           {
10154             Elf_External_Verdef * edefs;
10155             unsigned int idx;
10156             unsigned int cnt;
10157             unsigned int end;
10158             char * endbuf;
10159
10160             found = TRUE;
10161
10162             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10163                     printable_section_name (section),
10164                     section->sh_info);
10165
10166             printf (_("  Addr: 0x"));
10167             printf_vma (section->sh_addr);
10168             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10169                     (unsigned long) section->sh_offset, section->sh_link,
10170                     printable_section_name_from_index (section->sh_link));
10171
10172             edefs = (Elf_External_Verdef *)
10173                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10174                           _("version definition section"));
10175             if (!edefs)
10176               break;
10177             endbuf = (char *) edefs + section->sh_size;
10178
10179             /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
10180             end = (section->sh_info < section->sh_size
10181                    ? section->sh_info : section->sh_size);
10182             for (idx = cnt = 0; cnt < end; ++cnt)
10183               {
10184                 char * vstart;
10185                 Elf_External_Verdef * edef;
10186                 Elf_Internal_Verdef ent;
10187                 Elf_External_Verdaux * eaux;
10188                 Elf_Internal_Verdaux aux;
10189                 unsigned int isum;
10190                 int j;
10191
10192                 /* Check for very large indices.  */
10193                 if (idx > (size_t) (endbuf - (char *) edefs))
10194                   break;
10195
10196                 vstart = ((char *) edefs) + idx;
10197                 if (vstart + sizeof (*edef) > endbuf)
10198                   break;
10199
10200                 edef = (Elf_External_Verdef *) vstart;
10201
10202                 ent.vd_version = BYTE_GET (edef->vd_version);
10203                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10204                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10205                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10206                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10207                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10208                 ent.vd_next    = BYTE_GET (edef->vd_next);
10209
10210                 printf (_("  %#06x: Rev: %d  Flags: %s"),
10211                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10212
10213                 printf (_("  Index: %d  Cnt: %d  "),
10214                         ent.vd_ndx, ent.vd_cnt);
10215
10216                 /* Check for overflow and underflow.  */
10217                 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart)
10218                     || (vstart + ent.vd_aux < vstart))
10219                   break;
10220
10221                 vstart += ent.vd_aux;
10222
10223                 eaux = (Elf_External_Verdaux *) vstart;
10224
10225                 aux.vda_name = BYTE_GET (eaux->vda_name);
10226                 aux.vda_next = BYTE_GET (eaux->vda_next);
10227
10228                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10229                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10230                 else
10231                   printf (_("Name index: %ld\n"), aux.vda_name);
10232
10233                 isum = idx + ent.vd_aux;
10234
10235                 for (j = 1; j < ent.vd_cnt; j++)
10236                   {
10237                     /* Check for overflow.  */
10238                     if (aux.vda_next > (size_t) (endbuf - vstart))
10239                       break;
10240
10241                     isum   += aux.vda_next;
10242                     vstart += aux.vda_next;
10243
10244                     eaux = (Elf_External_Verdaux *) vstart;
10245                     if (vstart + sizeof (*eaux) > endbuf)
10246                       break;
10247
10248                     aux.vda_name = BYTE_GET (eaux->vda_name);
10249                     aux.vda_next = BYTE_GET (eaux->vda_next);
10250
10251                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10252                       printf (_("  %#06x: Parent %d: %s\n"),
10253                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10254                     else
10255                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
10256                               isum, j, aux.vda_name);
10257                   }
10258
10259                 if (j < ent.vd_cnt)
10260                   printf (_("  Version def aux past end of section\n"));
10261
10262                 /* PR 17531:
10263                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10264                 if (idx + ent.vd_next < idx)
10265                   break;
10266
10267                 idx += ent.vd_next;
10268               }
10269
10270             if (cnt < section->sh_info)
10271               printf (_("  Version definition past end of section\n"));
10272
10273             free (edefs);
10274           }
10275           break;
10276
10277         case SHT_GNU_verneed:
10278           {
10279             Elf_External_Verneed * eneed;
10280             unsigned int idx;
10281             unsigned int cnt;
10282             char * endbuf;
10283
10284             found = TRUE;
10285
10286             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10287                     printable_section_name (section), section->sh_info);
10288
10289             printf (_(" Addr: 0x"));
10290             printf_vma (section->sh_addr);
10291             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10292                     (unsigned long) section->sh_offset, section->sh_link,
10293                     printable_section_name_from_index (section->sh_link));
10294
10295             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10296                                                        section->sh_offset, 1,
10297                                                        section->sh_size,
10298                                                        _("Version Needs section"));
10299             if (!eneed)
10300               break;
10301             endbuf = (char *) eneed + section->sh_size;
10302
10303             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10304               {
10305                 Elf_External_Verneed * entry;
10306                 Elf_Internal_Verneed ent;
10307                 unsigned int isum;
10308                 int j;
10309                 char * vstart;
10310
10311                 if (idx > (size_t) (endbuf - (char *) eneed))
10312                   break;
10313
10314                 vstart = ((char *) eneed) + idx;
10315                 if (vstart + sizeof (*entry) > endbuf)
10316                   break;
10317
10318                 entry = (Elf_External_Verneed *) vstart;
10319
10320                 ent.vn_version = BYTE_GET (entry->vn_version);
10321                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10322                 ent.vn_file    = BYTE_GET (entry->vn_file);
10323                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10324                 ent.vn_next    = BYTE_GET (entry->vn_next);
10325
10326                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
10327
10328                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10329                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10330                 else
10331                   printf (_("  File: %lx"), ent.vn_file);
10332
10333                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10334
10335                 /* Check for overflow.  */
10336                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10337                   break;
10338                 vstart += ent.vn_aux;
10339
10340                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10341                   {
10342                     Elf_External_Vernaux * eaux;
10343                     Elf_Internal_Vernaux aux;
10344
10345                     if (vstart + sizeof (*eaux) > endbuf)
10346                       break;
10347                     eaux = (Elf_External_Vernaux *) vstart;
10348
10349                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10350                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10351                     aux.vna_other = BYTE_GET (eaux->vna_other);
10352                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10353                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10354
10355                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10356                       printf (_("  %#06x:   Name: %s"),
10357                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10358                     else
10359                       printf (_("  %#06x:   Name index: %lx"),
10360                               isum, aux.vna_name);
10361
10362                     printf (_("  Flags: %s  Version: %d\n"),
10363                             get_ver_flags (aux.vna_flags), aux.vna_other);
10364
10365                     /* Check for overflow.  */
10366                     if (aux.vna_next > (size_t) (endbuf - vstart)
10367                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10368                       {
10369                         warn (_("Invalid vna_next field of %lx\n"),
10370                               aux.vna_next);
10371                         j = ent.vn_cnt;
10372                         break;
10373                       }
10374                     isum   += aux.vna_next;
10375                     vstart += aux.vna_next;
10376                   }
10377
10378                 if (j < ent.vn_cnt)
10379                   warn (_("Missing Version Needs auxillary information\n"));
10380
10381                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
10382                   {
10383                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10384                     cnt = section->sh_info;
10385                     break;
10386                   }
10387                 idx += ent.vn_next;
10388               }
10389
10390             if (cnt < section->sh_info)
10391               warn (_("Missing Version Needs information\n"));
10392
10393             free (eneed);
10394           }
10395           break;
10396
10397         case SHT_GNU_versym:
10398           {
10399             Elf_Internal_Shdr * link_section;
10400             size_t total;
10401             unsigned int cnt;
10402             unsigned char * edata;
10403             unsigned short * data;
10404             char * strtab;
10405             Elf_Internal_Sym * symbols;
10406             Elf_Internal_Shdr * string_sec;
10407             unsigned long num_syms;
10408             long off;
10409
10410             if (section->sh_link >= elf_header.e_shnum)
10411               break;
10412
10413             link_section = section_headers + section->sh_link;
10414             total = section->sh_size / sizeof (Elf_External_Versym);
10415
10416             if (link_section->sh_link >= elf_header.e_shnum)
10417               break;
10418
10419             found = TRUE;
10420
10421             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10422             if (symbols == NULL)
10423               break;
10424
10425             string_sec = section_headers + link_section->sh_link;
10426
10427             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10428                                         string_sec->sh_size,
10429                                         _("version string table"));
10430             if (!strtab)
10431               {
10432                 free (symbols);
10433                 break;
10434               }
10435
10436             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10437                     printable_section_name (section), (unsigned long) total);
10438
10439             printf (_(" Addr: "));
10440             printf_vma (section->sh_addr);
10441             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10442                     (unsigned long) section->sh_offset, section->sh_link,
10443                     printable_section_name (link_section));
10444
10445             off = offset_from_vma (file,
10446                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10447                                    total * sizeof (short));
10448             edata = (unsigned char *) get_data (NULL, file, off, total,
10449                                                 sizeof (short),
10450                                                 _("version symbol data"));
10451             if (!edata)
10452               {
10453                 free (strtab);
10454                 free (symbols);
10455                 break;
10456               }
10457
10458             data = (short unsigned int *) cmalloc (total, sizeof (short));
10459
10460             for (cnt = total; cnt --;)
10461               data[cnt] = byte_get (edata + cnt * sizeof (short),
10462                                     sizeof (short));
10463
10464             free (edata);
10465
10466             for (cnt = 0; cnt < total; cnt += 4)
10467               {
10468                 int j, nn;
10469                 char *name;
10470                 char *invalid = _("*invalid*");
10471
10472                 printf ("  %03x:", cnt);
10473
10474                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10475                   switch (data[cnt + j])
10476                     {
10477                     case 0:
10478                       fputs (_("   0 (*local*)    "), stdout);
10479                       break;
10480
10481                     case 1:
10482                       fputs (_("   1 (*global*)   "), stdout);
10483                       break;
10484
10485                     default:
10486                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10487                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10488
10489                       /* If this index value is greater than the size of the symbols
10490                          array, break to avoid an out-of-bounds read.  */
10491                       if ((unsigned long)(cnt + j) >= num_syms)
10492                         {
10493                           warn (_("invalid index into symbol array\n"));
10494                           break;
10495                         }
10496
10497                       name = NULL;
10498                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10499                         {
10500                           Elf_Internal_Verneed ivn;
10501                           unsigned long offset;
10502
10503                           offset = offset_from_vma
10504                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10505                              sizeof (Elf_External_Verneed));
10506
10507                           do
10508                             {
10509                               Elf_Internal_Vernaux ivna;
10510                               Elf_External_Verneed evn;
10511                               Elf_External_Vernaux evna;
10512                               unsigned long a_off;
10513
10514                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10515                                             _("version need")) == NULL)
10516                                 break;
10517
10518                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10519                               ivn.vn_next = BYTE_GET (evn.vn_next);
10520
10521                               a_off = offset + ivn.vn_aux;
10522
10523                               do
10524                                 {
10525                                   if (get_data (&evna, file, a_off, sizeof (evna),
10526                                                 1, _("version need aux (2)")) == NULL)
10527                                     {
10528                                       ivna.vna_next  = 0;
10529                                       ivna.vna_other = 0;
10530                                     }
10531                                   else
10532                                     {
10533                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10534                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10535                                     }
10536
10537                                   a_off += ivna.vna_next;
10538                                 }
10539                               while (ivna.vna_other != data[cnt + j]
10540                                      && ivna.vna_next != 0);
10541
10542                               if (ivna.vna_other == data[cnt + j])
10543                                 {
10544                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10545
10546                                   if (ivna.vna_name >= string_sec->sh_size)
10547                                     name = invalid;
10548                                   else
10549                                     name = strtab + ivna.vna_name;
10550                                   break;
10551                                 }
10552
10553                               offset += ivn.vn_next;
10554                             }
10555                           while (ivn.vn_next);
10556                         }
10557
10558                       if (data[cnt + j] != 0x8001
10559                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10560                         {
10561                           Elf_Internal_Verdef ivd;
10562                           Elf_External_Verdef evd;
10563                           unsigned long offset;
10564
10565                           offset = offset_from_vma
10566                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10567                              sizeof evd);
10568
10569                           do
10570                             {
10571                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10572                                             _("version def")) == NULL)
10573                                 {
10574                                   ivd.vd_next = 0;
10575                                   /* PR 17531: file: 046-1082287-0.004.  */
10576                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10577                                   break;
10578                                 }
10579                               else
10580                                 {
10581                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10582                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10583                                 }
10584
10585                               offset += ivd.vd_next;
10586                             }
10587                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10588                                  && ivd.vd_next != 0);
10589
10590                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10591                             {
10592                               Elf_External_Verdaux evda;
10593                               Elf_Internal_Verdaux ivda;
10594
10595                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10596
10597                               if (get_data (&evda, file,
10598                                             offset - ivd.vd_next + ivd.vd_aux,
10599                                             sizeof (evda), 1,
10600                                             _("version def aux")) == NULL)
10601                                 break;
10602
10603                               ivda.vda_name = BYTE_GET (evda.vda_name);
10604
10605                               if (ivda.vda_name >= string_sec->sh_size)
10606                                 name = invalid;
10607                               else if (name != NULL && name != invalid)
10608                                 name = _("*both*");
10609                               else
10610                                 name = strtab + ivda.vda_name;
10611                             }
10612                         }
10613                       if (name != NULL)
10614                         nn += printf ("(%s%-*s",
10615                                       name,
10616                                       12 - (int) strlen (name),
10617                                       ")");
10618
10619                       if (nn < 18)
10620                         printf ("%*c", 18 - nn, ' ');
10621                     }
10622
10623                 putchar ('\n');
10624               }
10625
10626             free (data);
10627             free (strtab);
10628             free (symbols);
10629           }
10630           break;
10631
10632         default:
10633           break;
10634         }
10635     }
10636
10637   if (! found)
10638     printf (_("\nNo version information found in this file.\n"));
10639
10640   return TRUE;
10641 }
10642
10643 static const char *
10644 get_symbol_binding (unsigned int binding)
10645 {
10646   static char buff[32];
10647
10648   switch (binding)
10649     {
10650     case STB_LOCAL:     return "LOCAL";
10651     case STB_GLOBAL:    return "GLOBAL";
10652     case STB_WEAK:      return "WEAK";
10653     default:
10654       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10655         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10656                   binding);
10657       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10658         {
10659           if (binding == STB_GNU_UNIQUE
10660               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10661                   /* GNU is still using the default value 0.  */
10662                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10663             return "UNIQUE";
10664           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10665         }
10666       else
10667         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10668       return buff;
10669     }
10670 }
10671
10672 static const char *
10673 get_symbol_type (unsigned int type)
10674 {
10675   static char buff[32];
10676
10677   switch (type)
10678     {
10679     case STT_NOTYPE:    return "NOTYPE";
10680     case STT_OBJECT:    return "OBJECT";
10681     case STT_FUNC:      return "FUNC";
10682     case STT_SECTION:   return "SECTION";
10683     case STT_FILE:      return "FILE";
10684     case STT_COMMON:    return "COMMON";
10685     case STT_TLS:       return "TLS";
10686     case STT_RELC:      return "RELC";
10687     case STT_SRELC:     return "SRELC";
10688     default:
10689       if (type >= STT_LOPROC && type <= STT_HIPROC)
10690         {
10691           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10692             return "THUMB_FUNC";
10693
10694           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10695             return "REGISTER";
10696
10697           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10698             return "PARISC_MILLI";
10699
10700           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10701         }
10702       else if (type >= STT_LOOS && type <= STT_HIOS)
10703         {
10704           if (elf_header.e_machine == EM_PARISC)
10705             {
10706               if (type == STT_HP_OPAQUE)
10707                 return "HP_OPAQUE";
10708               if (type == STT_HP_STUB)
10709                 return "HP_STUB";
10710             }
10711
10712           if (type == STT_GNU_IFUNC
10713               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10714                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10715                   /* GNU is still using the default value 0.  */
10716                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10717             return "IFUNC";
10718
10719           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10720         }
10721       else
10722         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10723       return buff;
10724     }
10725 }
10726
10727 static const char *
10728 get_symbol_visibility (unsigned int visibility)
10729 {
10730   switch (visibility)
10731     {
10732     case STV_DEFAULT:   return "DEFAULT";
10733     case STV_INTERNAL:  return "INTERNAL";
10734     case STV_HIDDEN:    return "HIDDEN";
10735     case STV_PROTECTED: return "PROTECTED";
10736     default:
10737       error (_("Unrecognized visibility value: %u"), visibility);
10738       return _("<unknown>");
10739     }
10740 }
10741
10742 static const char *
10743 get_solaris_symbol_visibility (unsigned int visibility)
10744 {
10745   switch (visibility)
10746     {
10747     case 4: return "EXPORTED";
10748     case 5: return "SINGLETON";
10749     case 6: return "ELIMINATE";
10750     default: return get_symbol_visibility (visibility);
10751     }
10752 }
10753
10754 static const char *
10755 get_mips_symbol_other (unsigned int other)
10756 {
10757   switch (other)
10758     {
10759     case STO_OPTIONAL:      return "OPTIONAL";
10760     case STO_MIPS_PLT:      return "MIPS PLT";
10761     case STO_MIPS_PIC:      return "MIPS PIC";
10762     case STO_MICROMIPS:     return "MICROMIPS";
10763     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10764     case STO_MIPS16:        return "MIPS16";
10765     default:                return NULL;
10766     }
10767 }
10768
10769 static const char *
10770 get_ia64_symbol_other (unsigned int other)
10771 {
10772   if (is_ia64_vms ())
10773     {
10774       static char res[32];
10775
10776       res[0] = 0;
10777
10778       /* Function types is for images and .STB files only.  */
10779       switch (elf_header.e_type)
10780         {
10781         case ET_DYN:
10782         case ET_EXEC:
10783           switch (VMS_ST_FUNC_TYPE (other))
10784             {
10785             case VMS_SFT_CODE_ADDR:
10786               strcat (res, " CA");
10787               break;
10788             case VMS_SFT_SYMV_IDX:
10789               strcat (res, " VEC");
10790               break;
10791             case VMS_SFT_FD:
10792               strcat (res, " FD");
10793               break;
10794             case VMS_SFT_RESERVE:
10795               strcat (res, " RSV");
10796               break;
10797             default:
10798               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10799                     VMS_ST_FUNC_TYPE (other));
10800               strcat (res, " <unknown>");
10801               break;
10802             }
10803           break;
10804         default:
10805           break;
10806         }
10807       switch (VMS_ST_LINKAGE (other))
10808         {
10809         case VMS_STL_IGNORE:
10810           strcat (res, " IGN");
10811           break;
10812         case VMS_STL_RESERVE:
10813           strcat (res, " RSV");
10814           break;
10815         case VMS_STL_STD:
10816           strcat (res, " STD");
10817           break;
10818         case VMS_STL_LNK:
10819           strcat (res, " LNK");
10820           break;
10821         default:
10822           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10823                 VMS_ST_LINKAGE (other));
10824           strcat (res, " <unknown>");
10825           break;
10826         }
10827
10828       if (res[0] != 0)
10829         return res + 1;
10830       else
10831         return res;
10832     }
10833   return NULL;
10834 }
10835
10836 static const char *
10837 get_ppc64_symbol_other (unsigned int other)
10838 {
10839   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10840     {
10841       static char buf[32];
10842       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10843                 PPC64_LOCAL_ENTRY_OFFSET (other));
10844       return buf;
10845     }
10846   return NULL;
10847 }
10848
10849 static const char *
10850 get_symbol_other (unsigned int other)
10851 {
10852   const char * result = NULL;
10853   static char buff [32];
10854
10855   if (other == 0)
10856     return "";
10857
10858   switch (elf_header.e_machine)
10859     {
10860     case EM_MIPS:
10861       result = get_mips_symbol_other (other);
10862       break;
10863     case EM_IA_64:
10864       result = get_ia64_symbol_other (other);
10865       break;
10866     case EM_PPC64:
10867       result = get_ppc64_symbol_other (other);
10868       break;
10869     default:
10870       result = NULL;
10871       break;
10872     }
10873
10874   if (result)
10875     return result;
10876
10877   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10878   return buff;
10879 }
10880
10881 static const char *
10882 get_symbol_index_type (unsigned int type)
10883 {
10884   static char buff[32];
10885
10886   switch (type)
10887     {
10888     case SHN_UNDEF:     return "UND";
10889     case SHN_ABS:       return "ABS";
10890     case SHN_COMMON:    return "COM";
10891     default:
10892       if (type == SHN_IA_64_ANSI_COMMON
10893           && elf_header.e_machine == EM_IA_64
10894           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10895         return "ANSI_COM";
10896       else if ((elf_header.e_machine == EM_X86_64
10897                 || elf_header.e_machine == EM_L1OM
10898                 || elf_header.e_machine == EM_K1OM)
10899                && type == SHN_X86_64_LCOMMON)
10900         return "LARGE_COM";
10901       else if ((type == SHN_MIPS_SCOMMON
10902                 && elf_header.e_machine == EM_MIPS)
10903                || (type == SHN_TIC6X_SCOMMON
10904                    && elf_header.e_machine == EM_TI_C6000))
10905         return "SCOM";
10906       else if (type == SHN_MIPS_SUNDEFINED
10907                && elf_header.e_machine == EM_MIPS)
10908         return "SUND";
10909       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10910         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10911       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10912         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10913       else if (type >= SHN_LORESERVE)
10914         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10915       else if (type >= elf_header.e_shnum)
10916         sprintf (buff, _("bad section index[%3d]"), type);
10917       else
10918         sprintf (buff, "%3d", type);
10919       break;
10920     }
10921
10922   return buff;
10923 }
10924
10925 static bfd_vma *
10926 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10927 {
10928   unsigned char * e_data;
10929   bfd_vma * i_data;
10930
10931   /* If the size_t type is smaller than the bfd_size_type, eg because
10932      you are building a 32-bit tool on a 64-bit host, then make sure
10933      that when (number) is cast to (size_t) no information is lost.  */
10934   if (sizeof (size_t) < sizeof (bfd_size_type)
10935       && (bfd_size_type) ((size_t) number) != number)
10936     {
10937       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10938                " elements of size %u\n"),
10939              number, ent_size);
10940       return NULL;
10941     }
10942
10943   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10944      attempting to allocate memory when the read is bound to fail.  */
10945   if (ent_size * number > current_file_size)
10946     {
10947       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10948              number);
10949       return NULL;
10950     }
10951
10952   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10953   if (e_data == NULL)
10954     {
10955       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10956              number);
10957       return NULL;
10958     }
10959
10960   if (fread (e_data, ent_size, (size_t) number, file) != number)
10961     {
10962       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10963              number * ent_size);
10964       free (e_data);
10965       return NULL;
10966     }
10967
10968   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10969   if (i_data == NULL)
10970     {
10971       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10972                " dynamic entries\n"),
10973              number);
10974       free (e_data);
10975       return NULL;
10976     }
10977
10978   while (number--)
10979     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10980
10981   free (e_data);
10982
10983   return i_data;
10984 }
10985
10986 static void
10987 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10988 {
10989   Elf_Internal_Sym * psym;
10990   int n;
10991
10992   n = print_vma (si, DEC_5);
10993   if (n < 5)
10994     fputs (&"     "[n], stdout);
10995   printf (" %3lu: ", hn);
10996
10997   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10998     {
10999       printf (_("<No info available for dynamic symbol number %lu>\n"),
11000               (unsigned long) si);
11001       return;
11002     }
11003
11004   psym = dynamic_symbols + si;
11005   print_vma (psym->st_value, LONG_HEX);
11006   putchar (' ');
11007   print_vma (psym->st_size, DEC_5);
11008
11009   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11010   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11011
11012   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11013     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11014   else
11015     {
11016       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11017
11018       printf (" %-7s",  get_symbol_visibility (vis));
11019       /* Check to see if any other bits in the st_other field are set.
11020          Note - displaying this information disrupts the layout of the
11021          table being generated, but for the moment this case is very
11022          rare.  */
11023       if (psym->st_other ^ vis)
11024         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11025     }
11026
11027   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11028   if (VALID_DYNAMIC_NAME (psym->st_name))
11029     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11030   else
11031     printf (_(" <corrupt: %14ld>"), psym->st_name);
11032   putchar ('\n');
11033 }
11034
11035 static const char *
11036 get_symbol_version_string (FILE *                       file,
11037                            bfd_boolean                  is_dynsym,
11038                            const char *                 strtab,
11039                            unsigned long int            strtab_size,
11040                            unsigned int                 si,
11041                            Elf_Internal_Sym *           psym,
11042                            enum versioned_symbol_info * sym_info,
11043                            unsigned short *             vna_other)
11044 {
11045   unsigned char data[2];
11046   unsigned short vers_data;
11047   unsigned long offset;
11048
11049   if (!is_dynsym
11050       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11051     return NULL;
11052
11053   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11054                             sizeof data + si * sizeof (vers_data));
11055
11056   if (get_data (&data, file, offset + si * sizeof (vers_data),
11057                 sizeof (data), 1, _("version data")) == NULL)
11058     return NULL;
11059
11060   vers_data = byte_get (data, 2);
11061
11062   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11063     return NULL;
11064
11065   /* Usually we'd only see verdef for defined symbols, and verneed for
11066      undefined symbols.  However, symbols defined by the linker in
11067      .dynbss for variables copied from a shared library in order to
11068      avoid text relocations are defined yet have verneed.  We could
11069      use a heuristic to detect the special case, for example, check
11070      for verneed first on symbols defined in SHT_NOBITS sections, but
11071      it is simpler and more reliable to just look for both verdef and
11072      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11073
11074   if (psym->st_shndx != SHN_UNDEF
11075       && vers_data != 0x8001
11076       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11077     {
11078       Elf_Internal_Verdef ivd;
11079       Elf_Internal_Verdaux ivda;
11080       Elf_External_Verdaux evda;
11081       unsigned long off;
11082
11083       off = offset_from_vma (file,
11084                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11085                              sizeof (Elf_External_Verdef));
11086
11087       do
11088         {
11089           Elf_External_Verdef evd;
11090
11091           if (get_data (&evd, file, off, sizeof (evd), 1,
11092                         _("version def")) == NULL)
11093             {
11094               ivd.vd_ndx = 0;
11095               ivd.vd_aux = 0;
11096               ivd.vd_next = 0;
11097             }
11098           else
11099             {
11100               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11101               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11102               ivd.vd_next = BYTE_GET (evd.vd_next);
11103             }
11104
11105           off += ivd.vd_next;
11106         }
11107       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11108
11109       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11110         {
11111           off -= ivd.vd_next;
11112           off += ivd.vd_aux;
11113
11114           if (get_data (&evda, file, off, sizeof (evda), 1,
11115                         _("version def aux")) != NULL)
11116             {
11117               ivda.vda_name = BYTE_GET (evda.vda_name);
11118
11119               if (psym->st_name != ivda.vda_name)
11120                 {
11121                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11122                                ? symbol_hidden : symbol_public);
11123                   return (ivda.vda_name < strtab_size
11124                           ? strtab + ivda.vda_name : _("<corrupt>"));
11125                 }
11126             }
11127         }
11128     }
11129
11130   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11131     {
11132       Elf_External_Verneed evn;
11133       Elf_Internal_Verneed ivn;
11134       Elf_Internal_Vernaux ivna;
11135
11136       offset = offset_from_vma (file,
11137                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11138                                 sizeof evn);
11139       do
11140         {
11141           unsigned long vna_off;
11142
11143           if (get_data (&evn, file, offset, sizeof (evn), 1,
11144                         _("version need")) == NULL)
11145             {
11146               ivna.vna_next = 0;
11147               ivna.vna_other = 0;
11148               ivna.vna_name = 0;
11149               break;
11150             }
11151
11152           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11153           ivn.vn_next = BYTE_GET (evn.vn_next);
11154
11155           vna_off = offset + ivn.vn_aux;
11156
11157           do
11158             {
11159               Elf_External_Vernaux evna;
11160
11161               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11162                             _("version need aux (3)")) == NULL)
11163                 {
11164                   ivna.vna_next = 0;
11165                   ivna.vna_other = 0;
11166                   ivna.vna_name = 0;
11167                 }
11168               else
11169                 {
11170                   ivna.vna_other = BYTE_GET (evna.vna_other);
11171                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11172                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11173                 }
11174
11175               vna_off += ivna.vna_next;
11176             }
11177           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11178
11179           if (ivna.vna_other == vers_data)
11180             break;
11181
11182           offset += ivn.vn_next;
11183         }
11184       while (ivn.vn_next != 0);
11185
11186       if (ivna.vna_other == vers_data)
11187         {
11188           *sym_info = symbol_undefined;
11189           *vna_other = ivna.vna_other;
11190           return (ivna.vna_name < strtab_size
11191                   ? strtab + ivna.vna_name : _("<corrupt>"));
11192         }
11193     }
11194   return NULL;
11195 }
11196
11197 /* Dump the symbol table.  */
11198 static bfd_boolean
11199 process_symbol_table (FILE * file)
11200 {
11201   Elf_Internal_Shdr * section;
11202   bfd_size_type nbuckets = 0;
11203   bfd_size_type nchains = 0;
11204   bfd_vma * buckets = NULL;
11205   bfd_vma * chains = NULL;
11206   bfd_vma ngnubuckets = 0;
11207   bfd_vma * gnubuckets = NULL;
11208   bfd_vma * gnuchains = NULL;
11209   bfd_vma gnusymidx = 0;
11210   bfd_size_type ngnuchains = 0;
11211
11212   if (!do_syms && !do_dyn_syms && !do_histogram)
11213     return TRUE;
11214
11215   if (dynamic_info[DT_HASH]
11216       && (do_histogram
11217           || (do_using_dynamic
11218               && !do_dyn_syms
11219               && dynamic_strings != NULL)))
11220     {
11221       unsigned char nb[8];
11222       unsigned char nc[8];
11223       unsigned int hash_ent_size = 4;
11224
11225       if ((elf_header.e_machine == EM_ALPHA
11226            || elf_header.e_machine == EM_S390
11227            || elf_header.e_machine == EM_S390_OLD)
11228           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11229         hash_ent_size = 8;
11230
11231       if (fseek (file,
11232                  (archive_file_offset
11233                   + offset_from_vma (file, dynamic_info[DT_HASH],
11234                                      sizeof nb + sizeof nc)),
11235                  SEEK_SET))
11236         {
11237           error (_("Unable to seek to start of dynamic information\n"));
11238           goto no_hash;
11239         }
11240
11241       if (fread (nb, hash_ent_size, 1, file) != 1)
11242         {
11243           error (_("Failed to read in number of buckets\n"));
11244           goto no_hash;
11245         }
11246
11247       if (fread (nc, hash_ent_size, 1, file) != 1)
11248         {
11249           error (_("Failed to read in number of chains\n"));
11250           goto no_hash;
11251         }
11252
11253       nbuckets = byte_get (nb, hash_ent_size);
11254       nchains  = byte_get (nc, hash_ent_size);
11255
11256       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11257       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11258
11259     no_hash:
11260       if (buckets == NULL || chains == NULL)
11261         {
11262           if (do_using_dynamic)
11263             return FALSE;
11264           free (buckets);
11265           free (chains);
11266           buckets = NULL;
11267           chains = NULL;
11268           nbuckets = 0;
11269           nchains = 0;
11270         }
11271     }
11272
11273   if (dynamic_info_DT_GNU_HASH
11274       && (do_histogram
11275           || (do_using_dynamic
11276               && !do_dyn_syms
11277               && dynamic_strings != NULL)))
11278     {
11279       unsigned char nb[16];
11280       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11281       bfd_vma buckets_vma;
11282
11283       if (fseek (file,
11284                  (archive_file_offset
11285                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11286                                      sizeof nb)),
11287                  SEEK_SET))
11288         {
11289           error (_("Unable to seek to start of dynamic information\n"));
11290           goto no_gnu_hash;
11291         }
11292
11293       if (fread (nb, 16, 1, file) != 1)
11294         {
11295           error (_("Failed to read in number of buckets\n"));
11296           goto no_gnu_hash;
11297         }
11298
11299       ngnubuckets = byte_get (nb, 4);
11300       gnusymidx = byte_get (nb + 4, 4);
11301       bitmaskwords = byte_get (nb + 8, 4);
11302       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11303       if (is_32bit_elf)
11304         buckets_vma += bitmaskwords * 4;
11305       else
11306         buckets_vma += bitmaskwords * 8;
11307
11308       if (fseek (file,
11309                  (archive_file_offset
11310                   + offset_from_vma (file, buckets_vma, 4)),
11311                  SEEK_SET))
11312         {
11313           error (_("Unable to seek to start of dynamic information\n"));
11314           goto no_gnu_hash;
11315         }
11316
11317       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11318
11319       if (gnubuckets == NULL)
11320         goto no_gnu_hash;
11321
11322       for (i = 0; i < ngnubuckets; i++)
11323         if (gnubuckets[i] != 0)
11324           {
11325             if (gnubuckets[i] < gnusymidx)
11326               return FALSE;
11327
11328             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11329               maxchain = gnubuckets[i];
11330           }
11331
11332       if (maxchain == 0xffffffff)
11333         goto no_gnu_hash;
11334
11335       maxchain -= gnusymidx;
11336
11337       if (fseek (file,
11338                  (archive_file_offset
11339                   + offset_from_vma (file, buckets_vma
11340                                            + 4 * (ngnubuckets + maxchain), 4)),
11341                  SEEK_SET))
11342         {
11343           error (_("Unable to seek to start of dynamic information\n"));
11344           goto no_gnu_hash;
11345         }
11346
11347       do
11348         {
11349           if (fread (nb, 4, 1, file) != 1)
11350             {
11351               error (_("Failed to determine last chain length\n"));
11352               goto no_gnu_hash;
11353             }
11354
11355           if (maxchain + 1 == 0)
11356             goto no_gnu_hash;
11357
11358           ++maxchain;
11359         }
11360       while ((byte_get (nb, 4) & 1) == 0);
11361
11362       if (fseek (file,
11363                  (archive_file_offset
11364                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11365                  SEEK_SET))
11366         {
11367           error (_("Unable to seek to start of dynamic information\n"));
11368           goto no_gnu_hash;
11369         }
11370
11371       gnuchains = get_dynamic_data (file, maxchain, 4);
11372       ngnuchains = maxchain;
11373
11374     no_gnu_hash:
11375       if (gnuchains == NULL)
11376         {
11377           free (gnubuckets);
11378           gnubuckets = NULL;
11379           ngnubuckets = 0;
11380           if (do_using_dynamic)
11381             return FALSE;
11382         }
11383     }
11384
11385   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11386       && do_syms
11387       && do_using_dynamic
11388       && dynamic_strings != NULL
11389       && dynamic_symbols != NULL)
11390     {
11391       unsigned long hn;
11392
11393       if (dynamic_info[DT_HASH])
11394         {
11395           bfd_vma si;
11396
11397           printf (_("\nSymbol table for image:\n"));
11398           if (is_32bit_elf)
11399             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11400           else
11401             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11402
11403           for (hn = 0; hn < nbuckets; hn++)
11404             {
11405               if (! buckets[hn])
11406                 continue;
11407
11408               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11409                 print_dynamic_symbol (si, hn);
11410             }
11411         }
11412
11413       if (dynamic_info_DT_GNU_HASH)
11414         {
11415           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11416           if (is_32bit_elf)
11417             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11418           else
11419             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11420
11421           for (hn = 0; hn < ngnubuckets; ++hn)
11422             if (gnubuckets[hn] != 0)
11423               {
11424                 bfd_vma si = gnubuckets[hn];
11425                 bfd_vma off = si - gnusymidx;
11426
11427                 do
11428                   {
11429                     print_dynamic_symbol (si, hn);
11430                     si++;
11431                   }
11432                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11433               }
11434         }
11435     }
11436   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11437            && section_headers != NULL)
11438     {
11439       unsigned int i;
11440
11441       for (i = 0, section = section_headers;
11442            i < elf_header.e_shnum;
11443            i++, section++)
11444         {
11445           unsigned int si;
11446           char * strtab = NULL;
11447           unsigned long int strtab_size = 0;
11448           Elf_Internal_Sym * symtab;
11449           Elf_Internal_Sym * psym;
11450           unsigned long num_syms;
11451
11452           if ((section->sh_type != SHT_SYMTAB
11453                && section->sh_type != SHT_DYNSYM)
11454               || (!do_syms
11455                   && section->sh_type == SHT_SYMTAB))
11456             continue;
11457
11458           if (section->sh_entsize == 0)
11459             {
11460               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11461                       printable_section_name (section));
11462               continue;
11463             }
11464
11465           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11466                   printable_section_name (section),
11467                   (unsigned long) (section->sh_size / section->sh_entsize));
11468
11469           if (is_32bit_elf)
11470             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11471           else
11472             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11473
11474           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11475           if (symtab == NULL)
11476             continue;
11477
11478           if (section->sh_link == elf_header.e_shstrndx)
11479             {
11480               strtab = string_table;
11481               strtab_size = string_table_length;
11482             }
11483           else if (section->sh_link < elf_header.e_shnum)
11484             {
11485               Elf_Internal_Shdr * string_sec;
11486
11487               string_sec = section_headers + section->sh_link;
11488
11489               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11490                                           1, string_sec->sh_size,
11491                                           _("string table"));
11492               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11493             }
11494
11495           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11496             {
11497               const char *version_string;
11498               enum versioned_symbol_info sym_info;
11499               unsigned short vna_other;
11500
11501               printf ("%6d: ", si);
11502               print_vma (psym->st_value, LONG_HEX);
11503               putchar (' ');
11504               print_vma (psym->st_size, DEC_5);
11505               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11506               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11507               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11508                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11509               else
11510                 {
11511                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11512
11513                   printf (" %-7s", get_symbol_visibility (vis));
11514                   /* Check to see if any other bits in the st_other field are set.
11515                      Note - displaying this information disrupts the layout of the
11516                      table being generated, but for the moment this case is very rare.  */
11517                   if (psym->st_other ^ vis)
11518                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11519                 }
11520               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11521               print_symbol (25, psym->st_name < strtab_size
11522                             ? strtab + psym->st_name : _("<corrupt>"));
11523
11524               version_string
11525                 = get_symbol_version_string (file,
11526                                              section->sh_type == SHT_DYNSYM,
11527                                              strtab, strtab_size, si,
11528                                              psym, &sym_info, &vna_other);
11529               if (version_string)
11530                 {
11531                   if (sym_info == symbol_undefined)
11532                     printf ("@%s (%d)", version_string, vna_other);
11533                   else
11534                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11535                             version_string);
11536                 }
11537
11538               putchar ('\n');
11539
11540               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11541                   && si >= section->sh_info
11542                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11543                   && elf_header.e_machine != EM_MIPS
11544                   /* Solaris binaries have been found to violate this requirement as
11545                      well.  Not sure if this is a bug or an ABI requirement.  */
11546                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11547                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11548                       si, printable_section_name (section), section->sh_info);
11549             }
11550
11551           free (symtab);
11552           if (strtab != string_table)
11553             free (strtab);
11554         }
11555     }
11556   else if (do_syms)
11557     printf
11558       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11559
11560   if (do_histogram && buckets != NULL)
11561     {
11562       unsigned long * lengths;
11563       unsigned long * counts;
11564       unsigned long hn;
11565       bfd_vma si;
11566       unsigned long maxlength = 0;
11567       unsigned long nzero_counts = 0;
11568       unsigned long nsyms = 0;
11569       unsigned long chained;
11570
11571       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11572               (unsigned long) nbuckets);
11573
11574       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11575       if (lengths == NULL)
11576         {
11577           error (_("Out of memory allocating space for histogram buckets\n"));
11578           return FALSE;
11579         }
11580
11581       printf (_(" Length  Number     %% of total  Coverage\n"));
11582       for (hn = 0; hn < nbuckets; ++hn)
11583         {
11584           for (si = buckets[hn], chained = 0;
11585                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11586                si = chains[si], ++chained)
11587             {
11588               ++nsyms;
11589               if (maxlength < ++lengths[hn])
11590                 ++maxlength;
11591             }
11592
11593             /* PR binutils/17531: A corrupt binary could contain broken
11594                histogram data.  Do not go into an infinite loop trying
11595                to process it.  */
11596             if (chained > nchains)
11597               {
11598                 error (_("histogram chain is corrupt\n"));
11599                 break;
11600               }
11601         }
11602
11603       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11604       if (counts == NULL)
11605         {
11606           free (lengths);
11607           error (_("Out of memory allocating space for histogram counts\n"));
11608           return FALSE;
11609         }
11610
11611       for (hn = 0; hn < nbuckets; ++hn)
11612         ++counts[lengths[hn]];
11613
11614       if (nbuckets > 0)
11615         {
11616           unsigned long i;
11617           printf ("      0  %-10lu (%5.1f%%)\n",
11618                   counts[0], (counts[0] * 100.0) / nbuckets);
11619           for (i = 1; i <= maxlength; ++i)
11620             {
11621               nzero_counts += counts[i] * i;
11622               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11623                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11624                       (nzero_counts * 100.0) / nsyms);
11625             }
11626         }
11627
11628       free (counts);
11629       free (lengths);
11630     }
11631
11632   if (buckets != NULL)
11633     {
11634       free (buckets);
11635       free (chains);
11636     }
11637
11638   if (do_histogram && gnubuckets != NULL)
11639     {
11640       unsigned long * lengths;
11641       unsigned long * counts;
11642       unsigned long hn;
11643       unsigned long maxlength = 0;
11644       unsigned long nzero_counts = 0;
11645       unsigned long nsyms = 0;
11646
11647       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11648               (unsigned long) ngnubuckets);
11649
11650       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11651       if (lengths == NULL)
11652         {
11653           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11654           return FALSE;
11655         }
11656
11657       printf (_(" Length  Number     %% of total  Coverage\n"));
11658
11659       for (hn = 0; hn < ngnubuckets; ++hn)
11660         if (gnubuckets[hn] != 0)
11661           {
11662             bfd_vma off, length = 1;
11663
11664             for (off = gnubuckets[hn] - gnusymidx;
11665                  /* PR 17531 file: 010-77222-0.004.  */
11666                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11667                  ++off)
11668               ++length;
11669             lengths[hn] = length;
11670             if (length > maxlength)
11671               maxlength = length;
11672             nsyms += length;
11673           }
11674
11675       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11676       if (counts == NULL)
11677         {
11678           free (lengths);
11679           error (_("Out of memory allocating space for gnu histogram counts\n"));
11680           return FALSE;
11681         }
11682
11683       for (hn = 0; hn < ngnubuckets; ++hn)
11684         ++counts[lengths[hn]];
11685
11686       if (ngnubuckets > 0)
11687         {
11688           unsigned long j;
11689           printf ("      0  %-10lu (%5.1f%%)\n",
11690                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11691           for (j = 1; j <= maxlength; ++j)
11692             {
11693               nzero_counts += counts[j] * j;
11694               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11695                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11696                       (nzero_counts * 100.0) / nsyms);
11697             }
11698         }
11699
11700       free (counts);
11701       free (lengths);
11702       free (gnubuckets);
11703       free (gnuchains);
11704     }
11705
11706   return TRUE;
11707 }
11708
11709 static bfd_boolean
11710 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11711 {
11712   unsigned int i;
11713
11714   if (dynamic_syminfo == NULL
11715       || !do_dynamic)
11716     /* No syminfo, this is ok.  */
11717     return TRUE;
11718
11719   /* There better should be a dynamic symbol section.  */
11720   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11721     return FALSE;
11722
11723   if (dynamic_addr)
11724     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11725             dynamic_syminfo_offset, dynamic_syminfo_nent);
11726
11727   printf (_(" Num: Name                           BoundTo     Flags\n"));
11728   for (i = 0; i < dynamic_syminfo_nent; ++i)
11729     {
11730       unsigned short int flags = dynamic_syminfo[i].si_flags;
11731
11732       printf ("%4d: ", i);
11733       if (i >= num_dynamic_syms)
11734         printf (_("<corrupt index>"));
11735       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11736         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11737       else
11738         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11739       putchar (' ');
11740
11741       switch (dynamic_syminfo[i].si_boundto)
11742         {
11743         case SYMINFO_BT_SELF:
11744           fputs ("SELF       ", stdout);
11745           break;
11746         case SYMINFO_BT_PARENT:
11747           fputs ("PARENT     ", stdout);
11748           break;
11749         default:
11750           if (dynamic_syminfo[i].si_boundto > 0
11751               && dynamic_syminfo[i].si_boundto < dynamic_nent
11752               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11753             {
11754               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11755               putchar (' ' );
11756             }
11757           else
11758             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11759           break;
11760         }
11761
11762       if (flags & SYMINFO_FLG_DIRECT)
11763         printf (" DIRECT");
11764       if (flags & SYMINFO_FLG_PASSTHRU)
11765         printf (" PASSTHRU");
11766       if (flags & SYMINFO_FLG_COPY)
11767         printf (" COPY");
11768       if (flags & SYMINFO_FLG_LAZYLOAD)
11769         printf (" LAZYLOAD");
11770
11771       puts ("");
11772     }
11773
11774   return TRUE;
11775 }
11776
11777 #define IN_RANGE(START,END,ADDR,OFF)            \
11778   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11779
11780 /* Check to see if the given reloc needs to be handled in a target specific
11781    manner.  If so then process the reloc and return TRUE otherwise return
11782    FALSE.
11783
11784    If called with reloc == NULL, then this is a signal that reloc processing
11785    for the current section has finished, and any saved state should be
11786    discarded.  */
11787
11788 static bfd_boolean
11789 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11790                                 unsigned char *     start,
11791                                 unsigned char *     end,
11792                                 Elf_Internal_Sym *  symtab,
11793                                 unsigned long       num_syms)
11794 {
11795   unsigned int reloc_type = 0;
11796   unsigned long sym_index = 0;
11797
11798   if (reloc)
11799     {
11800       reloc_type = get_reloc_type (reloc->r_info);
11801       sym_index = get_reloc_symindex (reloc->r_info);
11802     }
11803
11804   switch (elf_header.e_machine)
11805     {
11806     case EM_MSP430:
11807     case EM_MSP430_OLD:
11808       {
11809         static Elf_Internal_Sym * saved_sym = NULL;
11810
11811         if (reloc == NULL)
11812           {
11813             saved_sym = NULL;
11814             return TRUE;
11815           }
11816
11817         switch (reloc_type)
11818           {
11819           case 10: /* R_MSP430_SYM_DIFF */
11820             if (uses_msp430x_relocs ())
11821               break;
11822             /* Fall through.  */
11823           case 21: /* R_MSP430X_SYM_DIFF */
11824             /* PR 21139.  */
11825             if (sym_index >= num_syms)
11826               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11827                      sym_index);
11828             else
11829               saved_sym = symtab + sym_index;
11830             return TRUE;
11831
11832           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11833           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11834             goto handle_sym_diff;
11835
11836           case 5: /* R_MSP430_16_BYTE */
11837           case 9: /* R_MSP430_8 */
11838             if (uses_msp430x_relocs ())
11839               break;
11840             goto handle_sym_diff;
11841
11842           case 2: /* R_MSP430_ABS16 */
11843           case 15: /* R_MSP430X_ABS16 */
11844             if (! uses_msp430x_relocs ())
11845               break;
11846             goto handle_sym_diff;
11847
11848           handle_sym_diff:
11849             if (saved_sym != NULL)
11850               {
11851                 int reloc_size = reloc_type == 1 ? 4 : 2;
11852                 bfd_vma value;
11853
11854                 if (sym_index >= num_syms)
11855                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11856                          sym_index);
11857                 else
11858                   {
11859                     value = reloc->r_addend + (symtab[sym_index].st_value
11860                                                - saved_sym->st_value);
11861
11862                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11863                       byte_put (start + reloc->r_offset, value, reloc_size);
11864                     else
11865                       /* PR 21137 */
11866                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11867                              (long) reloc->r_offset);
11868                   }
11869
11870                 saved_sym = NULL;
11871                 return TRUE;
11872               }
11873             break;
11874
11875           default:
11876             if (saved_sym != NULL)
11877               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11878             break;
11879           }
11880         break;
11881       }
11882
11883     case EM_MN10300:
11884     case EM_CYGNUS_MN10300:
11885       {
11886         static Elf_Internal_Sym * saved_sym = NULL;
11887
11888         if (reloc == NULL)
11889           {
11890             saved_sym = NULL;
11891             return TRUE;
11892           }
11893
11894         switch (reloc_type)
11895           {
11896           case 34: /* R_MN10300_ALIGN */
11897             return TRUE;
11898           case 33: /* R_MN10300_SYM_DIFF */
11899             if (sym_index >= num_syms)
11900               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11901                      sym_index);
11902             else
11903               saved_sym = symtab + sym_index;
11904             return TRUE;
11905
11906           case 1: /* R_MN10300_32 */
11907           case 2: /* R_MN10300_16 */
11908             if (saved_sym != NULL)
11909               {
11910                 int reloc_size = reloc_type == 1 ? 4 : 2;
11911                 bfd_vma value;
11912
11913                 if (sym_index >= num_syms)
11914                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11915                          sym_index);
11916                 else
11917                   {
11918                     value = reloc->r_addend + (symtab[sym_index].st_value
11919                                                - saved_sym->st_value);
11920
11921                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11922                       byte_put (start + reloc->r_offset, value, reloc_size);
11923                     else
11924                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11925                              (long) reloc->r_offset);
11926                   }
11927
11928                 saved_sym = NULL;
11929                 return TRUE;
11930               }
11931             break;
11932           default:
11933             if (saved_sym != NULL)
11934               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11935             break;
11936           }
11937         break;
11938       }
11939
11940     case EM_RL78:
11941       {
11942         static bfd_vma saved_sym1 = 0;
11943         static bfd_vma saved_sym2 = 0;
11944         static bfd_vma value;
11945
11946         if (reloc == NULL)
11947           {
11948             saved_sym1 = saved_sym2 = 0;
11949             return TRUE;
11950           }
11951
11952         switch (reloc_type)
11953           {
11954           case 0x80: /* R_RL78_SYM.  */
11955             saved_sym1 = saved_sym2;
11956             if (sym_index >= num_syms)
11957               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11958                      sym_index);
11959             else
11960               {
11961                 saved_sym2 = symtab[sym_index].st_value;
11962                 saved_sym2 += reloc->r_addend;
11963               }
11964             return TRUE;
11965
11966           case 0x83: /* R_RL78_OPsub.  */
11967             value = saved_sym1 - saved_sym2;
11968             saved_sym2 = saved_sym1 = 0;
11969             return TRUE;
11970             break;
11971
11972           case 0x41: /* R_RL78_ABS32.  */
11973             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11974               byte_put (start + reloc->r_offset, value, 4);
11975             else
11976               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11977                      (long) reloc->r_offset);
11978             value = 0;
11979             return TRUE;
11980
11981           case 0x43: /* R_RL78_ABS16.  */
11982             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11983               byte_put (start + reloc->r_offset, value, 2);
11984             else
11985               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11986                      (long) reloc->r_offset);
11987             value = 0;
11988             return TRUE;
11989
11990           default:
11991             break;
11992           }
11993         break;
11994       }
11995     }
11996
11997   return FALSE;
11998 }
11999
12000 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12001    DWARF debug sections.  This is a target specific test.  Note - we do not
12002    go through the whole including-target-headers-multiple-times route, (as
12003    we have already done with <elf/h8.h>) because this would become very
12004    messy and even then this function would have to contain target specific
12005    information (the names of the relocs instead of their numeric values).
12006    FIXME: This is not the correct way to solve this problem.  The proper way
12007    is to have target specific reloc sizing and typing functions created by
12008    the reloc-macros.h header, in the same way that it already creates the
12009    reloc naming functions.  */
12010
12011 static bfd_boolean
12012 is_32bit_abs_reloc (unsigned int reloc_type)
12013 {
12014   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12015   switch (elf_header.e_machine)
12016     {
12017     case EM_386:
12018     case EM_IAMCU:
12019       return reloc_type == 1; /* R_386_32.  */
12020     case EM_68K:
12021       return reloc_type == 1; /* R_68K_32.  */
12022     case EM_860:
12023       return reloc_type == 1; /* R_860_32.  */
12024     case EM_960:
12025       return reloc_type == 2; /* R_960_32.  */
12026     case EM_AARCH64:
12027       return (reloc_type == 258
12028               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12029     case EM_ADAPTEVA_EPIPHANY:
12030       return reloc_type == 3;
12031     case EM_ALPHA:
12032       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12033     case EM_ARC:
12034       return reloc_type == 1; /* R_ARC_32.  */
12035     case EM_ARC_COMPACT:
12036     case EM_ARC_COMPACT2:
12037       return reloc_type == 4; /* R_ARC_32.  */
12038     case EM_ARM:
12039       return reloc_type == 2; /* R_ARM_ABS32 */
12040     case EM_AVR_OLD:
12041     case EM_AVR:
12042       return reloc_type == 1;
12043     case EM_BLACKFIN:
12044       return reloc_type == 0x12; /* R_byte4_data.  */
12045     case EM_CRIS:
12046       return reloc_type == 3; /* R_CRIS_32.  */
12047     case EM_CR16:
12048       return reloc_type == 3; /* R_CR16_NUM32.  */
12049     case EM_CRX:
12050       return reloc_type == 15; /* R_CRX_NUM32.  */
12051     case EM_CYGNUS_FRV:
12052       return reloc_type == 1;
12053     case EM_CYGNUS_D10V:
12054     case EM_D10V:
12055       return reloc_type == 6; /* R_D10V_32.  */
12056     case EM_CYGNUS_D30V:
12057     case EM_D30V:
12058       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12059     case EM_DLX:
12060       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12061     case EM_CYGNUS_FR30:
12062     case EM_FR30:
12063       return reloc_type == 3; /* R_FR30_32.  */
12064     case EM_FT32:
12065       return reloc_type == 1; /* R_FT32_32.  */
12066     case EM_H8S:
12067     case EM_H8_300:
12068     case EM_H8_300H:
12069       return reloc_type == 1; /* R_H8_DIR32.  */
12070     case EM_IA_64:
12071       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12072         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
12073     case EM_IP2K_OLD:
12074     case EM_IP2K:
12075       return reloc_type == 2; /* R_IP2K_32.  */
12076     case EM_IQ2000:
12077       return reloc_type == 2; /* R_IQ2000_32.  */
12078     case EM_LATTICEMICO32:
12079       return reloc_type == 3; /* R_LM32_32.  */
12080     case EM_M32C_OLD:
12081     case EM_M32C:
12082       return reloc_type == 3; /* R_M32C_32.  */
12083     case EM_M32R:
12084       return reloc_type == 34; /* R_M32R_32_RELA.  */
12085     case EM_68HC11:
12086     case EM_68HC12:
12087       return reloc_type == 6; /* R_M68HC11_32.  */
12088     case EM_MCORE:
12089       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12090     case EM_CYGNUS_MEP:
12091       return reloc_type == 4; /* R_MEP_32.  */
12092     case EM_METAG:
12093       return reloc_type == 2; /* R_METAG_ADDR32.  */
12094     case EM_MICROBLAZE:
12095       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12096     case EM_MIPS:
12097       return reloc_type == 2; /* R_MIPS_32.  */
12098     case EM_MMIX:
12099       return reloc_type == 4; /* R_MMIX_32.  */
12100     case EM_CYGNUS_MN10200:
12101     case EM_MN10200:
12102       return reloc_type == 1; /* R_MN10200_32.  */
12103     case EM_CYGNUS_MN10300:
12104     case EM_MN10300:
12105       return reloc_type == 1; /* R_MN10300_32.  */
12106     case EM_MOXIE:
12107       return reloc_type == 1; /* R_MOXIE_32.  */
12108     case EM_MSP430_OLD:
12109     case EM_MSP430:
12110       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12111     case EM_MT:
12112       return reloc_type == 2; /* R_MT_32.  */
12113     case EM_NDS32:
12114       return reloc_type == 20; /* R_NDS32_RELA.  */
12115     case EM_ALTERA_NIOS2:
12116       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12117     case EM_NIOS32:
12118       return reloc_type == 1; /* R_NIOS_32.  */
12119     case EM_OR1K:
12120       return reloc_type == 1; /* R_OR1K_32.  */
12121     case EM_PARISC:
12122       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12123               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12124     case EM_PJ:
12125     case EM_PJ_OLD:
12126       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12127     case EM_PPC64:
12128       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12129     case EM_PPC:
12130       return reloc_type == 1; /* R_PPC_ADDR32.  */
12131     case EM_TI_PRU:
12132       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12133     case EM_RISCV:
12134       return reloc_type == 1; /* R_RISCV_32.  */
12135     case EM_RL78:
12136       return reloc_type == 1; /* R_RL78_DIR32.  */
12137     case EM_RX:
12138       return reloc_type == 1; /* R_RX_DIR32.  */
12139     case EM_S370:
12140       return reloc_type == 1; /* R_I370_ADDR31.  */
12141     case EM_S390_OLD:
12142     case EM_S390:
12143       return reloc_type == 4; /* R_S390_32.  */
12144     case EM_SCORE:
12145       return reloc_type == 8; /* R_SCORE_ABS32.  */
12146     case EM_SH:
12147       return reloc_type == 1; /* R_SH_DIR32.  */
12148     case EM_SPARC32PLUS:
12149     case EM_SPARCV9:
12150     case EM_SPARC:
12151       return reloc_type == 3 /* R_SPARC_32.  */
12152         || reloc_type == 23; /* R_SPARC_UA32.  */
12153     case EM_SPU:
12154       return reloc_type == 6; /* R_SPU_ADDR32 */
12155     case EM_TI_C6000:
12156       return reloc_type == 1; /* R_C6000_ABS32.  */
12157     case EM_TILEGX:
12158       return reloc_type == 2; /* R_TILEGX_32.  */
12159     case EM_TILEPRO:
12160       return reloc_type == 1; /* R_TILEPRO_32.  */
12161     case EM_CYGNUS_V850:
12162     case EM_V850:
12163       return reloc_type == 6; /* R_V850_ABS32.  */
12164     case EM_V800:
12165       return reloc_type == 0x33; /* R_V810_WORD.  */
12166     case EM_VAX:
12167       return reloc_type == 1; /* R_VAX_32.  */
12168     case EM_VISIUM:
12169       return reloc_type == 3;  /* R_VISIUM_32. */
12170     case EM_WEBASSEMBLY:
12171       return reloc_type == 1;  /* R_WASM32_32.  */
12172     case EM_X86_64:
12173     case EM_L1OM:
12174     case EM_K1OM:
12175       return reloc_type == 10; /* R_X86_64_32.  */
12176     case EM_XC16X:
12177     case EM_C166:
12178       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12179     case EM_XGATE:
12180       return reloc_type == 4; /* R_XGATE_32.  */
12181     case EM_XSTORMY16:
12182       return reloc_type == 1; /* R_XSTROMY16_32.  */
12183     case EM_XTENSA_OLD:
12184     case EM_XTENSA:
12185       return reloc_type == 1; /* R_XTENSA_32.  */
12186     default:
12187       {
12188         static unsigned int prev_warn = 0;
12189
12190         /* Avoid repeating the same warning multiple times.  */
12191         if (prev_warn != elf_header.e_machine)
12192           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12193                  elf_header.e_machine);
12194         prev_warn = elf_header.e_machine;
12195         return FALSE;
12196       }
12197     }
12198 }
12199
12200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12201    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12202
12203 static bfd_boolean
12204 is_32bit_pcrel_reloc (unsigned int reloc_type)
12205 {
12206   switch (elf_header.e_machine)
12207   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12208     {
12209     case EM_386:
12210     case EM_IAMCU:
12211       return reloc_type == 2;  /* R_386_PC32.  */
12212     case EM_68K:
12213       return reloc_type == 4;  /* R_68K_PC32.  */
12214     case EM_AARCH64:
12215       return reloc_type == 261; /* R_AARCH64_PREL32 */
12216     case EM_ADAPTEVA_EPIPHANY:
12217       return reloc_type == 6;
12218     case EM_ALPHA:
12219       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12220     case EM_ARC_COMPACT:
12221     case EM_ARC_COMPACT2:
12222       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12223     case EM_ARM:
12224       return reloc_type == 3;  /* R_ARM_REL32 */
12225     case EM_AVR_OLD:
12226     case EM_AVR:
12227       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12228     case EM_MICROBLAZE:
12229       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12230     case EM_OR1K:
12231       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12232     case EM_PARISC:
12233       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12234     case EM_PPC:
12235       return reloc_type == 26; /* R_PPC_REL32.  */
12236     case EM_PPC64:
12237       return reloc_type == 26; /* R_PPC64_REL32.  */
12238     case EM_S390_OLD:
12239     case EM_S390:
12240       return reloc_type == 5;  /* R_390_PC32.  */
12241     case EM_SH:
12242       return reloc_type == 2;  /* R_SH_REL32.  */
12243     case EM_SPARC32PLUS:
12244     case EM_SPARCV9:
12245     case EM_SPARC:
12246       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12247     case EM_SPU:
12248       return reloc_type == 13; /* R_SPU_REL32.  */
12249     case EM_TILEGX:
12250       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12251     case EM_TILEPRO:
12252       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12253     case EM_VISIUM:
12254       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12255     case EM_X86_64:
12256     case EM_L1OM:
12257     case EM_K1OM:
12258       return reloc_type == 2;  /* R_X86_64_PC32.  */
12259     case EM_XTENSA_OLD:
12260     case EM_XTENSA:
12261       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12262     default:
12263       /* Do not abort or issue an error message here.  Not all targets use
12264          pc-relative 32-bit relocs in their DWARF debug information and we
12265          have already tested for target coverage in is_32bit_abs_reloc.  A
12266          more helpful warning message will be generated by apply_relocations
12267          anyway, so just return.  */
12268       return FALSE;
12269     }
12270 }
12271
12272 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12273    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12274
12275 static bfd_boolean
12276 is_64bit_abs_reloc (unsigned int reloc_type)
12277 {
12278   switch (elf_header.e_machine)
12279     {
12280     case EM_AARCH64:
12281       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12282     case EM_ALPHA:
12283       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12284     case EM_IA_64:
12285       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
12286     case EM_PARISC:
12287       return reloc_type == 80; /* R_PARISC_DIR64.  */
12288     case EM_PPC64:
12289       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12290     case EM_RISCV:
12291       return reloc_type == 2; /* R_RISCV_64.  */
12292     case EM_SPARC32PLUS:
12293     case EM_SPARCV9:
12294     case EM_SPARC:
12295       return 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 == 0x4f; /* R_IA64_PCREL64LSB.  */
12326     case EM_PARISC:
12327       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12328     case EM_PPC64:
12329       return reloc_type == 44; /* R_PPC64_REL64.  */
12330     case EM_SPARC32PLUS:
12331     case EM_SPARCV9:
12332     case EM_SPARC:
12333       return reloc_type == 46; /* R_SPARC_DISP64.  */
12334     case EM_X86_64:
12335     case EM_L1OM:
12336     case EM_K1OM:
12337       return reloc_type == 24; /* R_X86_64_PC64.  */
12338     case EM_S390_OLD:
12339     case EM_S390:
12340       return reloc_type == 23;  /* R_S390_PC64.  */
12341     case EM_TILEGX:
12342       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12343     default:
12344       return FALSE;
12345     }
12346 }
12347
12348 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12349    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12350
12351 static bfd_boolean
12352 is_24bit_abs_reloc (unsigned int reloc_type)
12353 {
12354   switch (elf_header.e_machine)
12355     {
12356     case EM_CYGNUS_MN10200:
12357     case EM_MN10200:
12358       return reloc_type == 4; /* R_MN10200_24.  */
12359     case EM_FT32:
12360       return reloc_type == 5; /* R_FT32_20.  */
12361     default:
12362       return FALSE;
12363     }
12364 }
12365
12366 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12367    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12368
12369 static bfd_boolean
12370 is_16bit_abs_reloc (unsigned int reloc_type)
12371 {
12372   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12373   switch (elf_header.e_machine)
12374     {
12375     case EM_ARC:
12376     case EM_ARC_COMPACT:
12377     case EM_ARC_COMPACT2:
12378       return reloc_type == 2; /* R_ARC_16.  */
12379     case EM_ADAPTEVA_EPIPHANY:
12380       return reloc_type == 5;
12381     case EM_AVR_OLD:
12382     case EM_AVR:
12383       return reloc_type == 4; /* R_AVR_16.  */
12384     case EM_CYGNUS_D10V:
12385     case EM_D10V:
12386       return reloc_type == 3; /* R_D10V_16.  */
12387     case EM_H8S:
12388     case EM_H8_300:
12389     case EM_H8_300H:
12390       return reloc_type == R_H8_DIR16;
12391     case EM_IP2K_OLD:
12392     case EM_IP2K:
12393       return reloc_type == 1; /* R_IP2K_16.  */
12394     case EM_M32C_OLD:
12395     case EM_M32C:
12396       return reloc_type == 1; /* R_M32C_16 */
12397     case EM_CYGNUS_MN10200:
12398     case EM_MN10200:
12399       return reloc_type == 2; /* R_MN10200_16.  */
12400     case EM_CYGNUS_MN10300:
12401     case EM_MN10300:
12402       return reloc_type == 2; /* R_MN10300_16.  */
12403     case EM_MSP430:
12404       if (uses_msp430x_relocs ())
12405         return reloc_type == 2; /* R_MSP430_ABS16.  */
12406       /* Fall through.  */
12407     case EM_MSP430_OLD:
12408       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12409     case EM_NDS32:
12410       return reloc_type == 19; /* R_NDS32_RELA.  */
12411     case EM_ALTERA_NIOS2:
12412       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12413     case EM_NIOS32:
12414       return reloc_type == 9; /* R_NIOS_16.  */
12415     case EM_OR1K:
12416       return reloc_type == 2; /* R_OR1K_16.  */
12417     case EM_TI_PRU:
12418       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12419     case EM_TI_C6000:
12420       return reloc_type == 2; /* R_C6000_ABS16.  */
12421     case EM_VISIUM:
12422       return reloc_type == 2; /* R_VISIUM_16. */
12423     case EM_XC16X:
12424     case EM_C166:
12425       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12426     case EM_XGATE:
12427       return reloc_type == 3; /* R_XGATE_16.  */
12428     default:
12429       return FALSE;
12430     }
12431 }
12432
12433 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12434    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12435
12436 static bfd_boolean
12437 is_none_reloc (unsigned int reloc_type)
12438 {
12439   switch (elf_header.e_machine)
12440     {
12441     case EM_386:     /* R_386_NONE.  */
12442     case EM_68K:     /* R_68K_NONE.  */
12443     case EM_ADAPTEVA_EPIPHANY:
12444     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12445     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12446     case EM_ARC:     /* R_ARC_NONE.  */
12447     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12448     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12449     case EM_ARM:     /* R_ARM_NONE.  */
12450     case EM_C166:    /* R_XC16X_NONE.  */
12451     case EM_CRIS:    /* R_CRIS_NONE.  */
12452     case EM_FT32:    /* R_FT32_NONE.  */
12453     case EM_IA_64:   /* R_IA64_NONE.  */
12454     case EM_K1OM:    /* R_X86_64_NONE.  */
12455     case EM_L1OM:    /* R_X86_64_NONE.  */
12456     case EM_M32R:    /* R_M32R_NONE.  */
12457     case EM_MIPS:    /* R_MIPS_NONE.  */
12458     case EM_MN10300: /* R_MN10300_NONE.  */
12459     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12460     case EM_NIOS32:  /* R_NIOS_NONE.  */
12461     case EM_OR1K:    /* R_OR1K_NONE. */
12462     case EM_PARISC:  /* R_PARISC_NONE.  */
12463     case EM_PPC64:   /* R_PPC64_NONE.  */
12464     case EM_PPC:     /* R_PPC_NONE.  */
12465     case EM_RISCV:   /* R_RISCV_NONE.  */
12466     case EM_S390:    /* R_390_NONE.  */
12467     case EM_S390_OLD:
12468     case EM_SH:      /* R_SH_NONE.  */
12469     case EM_SPARC32PLUS:
12470     case EM_SPARC:   /* R_SPARC_NONE.  */
12471     case EM_SPARCV9:
12472     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12473     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12474     case EM_TI_C6000:/* R_C6000_NONE.  */
12475     case EM_X86_64:  /* R_X86_64_NONE.  */
12476     case EM_XC16X:
12477     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12478       return reloc_type == 0;
12479
12480     case EM_AARCH64:
12481       return reloc_type == 0 || reloc_type == 256;
12482     case EM_AVR_OLD:
12483     case EM_AVR:
12484       return (reloc_type == 0 /* R_AVR_NONE.  */
12485               || reloc_type == 30 /* R_AVR_DIFF8.  */
12486               || reloc_type == 31 /* R_AVR_DIFF16.  */
12487               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12488     case EM_METAG:
12489       return reloc_type == 3; /* R_METAG_NONE.  */
12490     case EM_NDS32:
12491       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12492               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12493               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12494               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12495               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12496     case EM_TI_PRU:
12497       return (reloc_type == 0       /* R_PRU_NONE.  */
12498               || reloc_type == 65   /* R_PRU_DIFF8.  */
12499               || reloc_type == 66   /* R_PRU_DIFF16.  */
12500               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12501     case EM_XTENSA_OLD:
12502     case EM_XTENSA:
12503       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12504               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12505               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12506               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12507     }
12508   return FALSE;
12509 }
12510
12511 /* Returns TRUE if there is a relocation against
12512    section NAME at OFFSET bytes.  */
12513
12514 bfd_boolean
12515 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12516 {
12517   Elf_Internal_Rela * relocs;
12518   Elf_Internal_Rela * rp;
12519
12520   if (dsec == NULL || dsec->reloc_info == NULL)
12521     return FALSE;
12522
12523   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12524
12525   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12526     if (rp->r_offset == offset)
12527       return TRUE;
12528
12529    return FALSE;
12530 }
12531
12532 /* Apply relocations to a section.
12533    Returns TRUE upon success, FALSE otherwise.
12534    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12535    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12536    will be set to the number of relocs loaded.
12537
12538    Note: So far support has been added only for those relocations
12539    which can be found in debug sections. FIXME: Add support for
12540    more relocations ?  */
12541
12542 static bfd_boolean
12543 apply_relocations (void *                     file,
12544                    const Elf_Internal_Shdr *  section,
12545                    unsigned char *            start,
12546                    bfd_size_type              size,
12547                    void **                    relocs_return,
12548                    unsigned long *            num_relocs_return)
12549 {
12550   Elf_Internal_Shdr * relsec;
12551   unsigned char * end = start + size;
12552   bfd_boolean res = TRUE;
12553
12554   if (relocs_return != NULL)
12555     {
12556       * (Elf_Internal_Rela **) relocs_return = NULL;
12557       * num_relocs_return = 0;
12558     }
12559
12560   if (elf_header.e_type != ET_REL)
12561     /* No relocs to apply.  */
12562     return TRUE;
12563
12564   /* Find the reloc section associated with the section.  */
12565   for (relsec = section_headers;
12566        relsec < section_headers + elf_header.e_shnum;
12567        ++relsec)
12568     {
12569       bfd_boolean is_rela;
12570       unsigned long num_relocs;
12571       Elf_Internal_Rela * relocs;
12572       Elf_Internal_Rela * rp;
12573       Elf_Internal_Shdr * symsec;
12574       Elf_Internal_Sym * symtab;
12575       unsigned long num_syms;
12576       Elf_Internal_Sym * sym;
12577
12578       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12579           || relsec->sh_info >= elf_header.e_shnum
12580           || section_headers + relsec->sh_info != section
12581           || relsec->sh_size == 0
12582           || relsec->sh_link >= elf_header.e_shnum)
12583         continue;
12584
12585       is_rela = relsec->sh_type == SHT_RELA;
12586
12587       if (is_rela)
12588         {
12589           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12590                                   relsec->sh_size, & relocs, & num_relocs))
12591             return FALSE;
12592         }
12593       else
12594         {
12595           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12596                                  relsec->sh_size, & relocs, & num_relocs))
12597             return FALSE;
12598         }
12599
12600       /* SH uses RELA but uses in place value instead of the addend field.  */
12601       if (elf_header.e_machine == EM_SH)
12602         is_rela = FALSE;
12603
12604       symsec = section_headers + relsec->sh_link;
12605       if (symsec->sh_type != SHT_SYMTAB
12606           && symsec->sh_type != SHT_DYNSYM)
12607         return FALSE;
12608       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12609
12610       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12611         {
12612           bfd_vma         addend;
12613           unsigned int    reloc_type;
12614           unsigned int    reloc_size;
12615           unsigned char * rloc;
12616           unsigned long   sym_index;
12617
12618           reloc_type = get_reloc_type (rp->r_info);
12619
12620           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12621             continue;
12622           else if (is_none_reloc (reloc_type))
12623             continue;
12624           else if (is_32bit_abs_reloc (reloc_type)
12625                    || is_32bit_pcrel_reloc (reloc_type))
12626             reloc_size = 4;
12627           else if (is_64bit_abs_reloc (reloc_type)
12628                    || is_64bit_pcrel_reloc (reloc_type))
12629             reloc_size = 8;
12630           else if (is_24bit_abs_reloc (reloc_type))
12631             reloc_size = 3;
12632           else if (is_16bit_abs_reloc (reloc_type))
12633             reloc_size = 2;
12634           else
12635             {
12636               static unsigned int prev_reloc = 0;
12637               if (reloc_type != prev_reloc)
12638                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12639                       reloc_type, printable_section_name (section));
12640               prev_reloc = reloc_type;
12641               res = FALSE;
12642               continue;
12643             }
12644
12645           rloc = start + rp->r_offset;
12646           if ((rloc + reloc_size) > end || (rloc < start))
12647             {
12648               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12649                     (unsigned long) rp->r_offset,
12650                     printable_section_name (section));
12651               res = FALSE;
12652               continue;
12653             }
12654
12655           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12656           if (sym_index >= num_syms)
12657             {
12658               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12659                     sym_index, printable_section_name (section));
12660               res = FALSE;
12661               continue;
12662             }
12663           sym = symtab + sym_index;
12664
12665           /* If the reloc has a symbol associated with it,
12666              make sure that it is of an appropriate type.
12667
12668              Relocations against symbols without type can happen.
12669              Gcc -feliminate-dwarf2-dups may generate symbols
12670              without type for debug info.
12671
12672              Icc generates relocations against function symbols
12673              instead of local labels.
12674
12675              Relocations against object symbols can happen, eg when
12676              referencing a global array.  For an example of this see
12677              the _clz.o binary in libgcc.a.  */
12678           if (sym != symtab
12679               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12680               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12681             {
12682               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12683                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12684                     (long int)(rp - relocs),
12685                     printable_section_name (relsec));
12686               res = FALSE;
12687               continue;
12688             }
12689
12690           addend = 0;
12691           if (is_rela)
12692             addend += rp->r_addend;
12693           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12694              partial_inplace.  */
12695           if (!is_rela
12696               || (elf_header.e_machine == EM_XTENSA
12697                   && reloc_type == 1)
12698               || ((elf_header.e_machine == EM_PJ
12699                    || elf_header.e_machine == EM_PJ_OLD)
12700                   && reloc_type == 1)
12701               || ((elf_header.e_machine == EM_D30V
12702                    || elf_header.e_machine == EM_CYGNUS_D30V)
12703                   && reloc_type == 12))
12704             addend += byte_get (rloc, reloc_size);
12705
12706           if (is_32bit_pcrel_reloc (reloc_type)
12707               || is_64bit_pcrel_reloc (reloc_type))
12708             {
12709               /* On HPPA, all pc-relative relocations are biased by 8.  */
12710               if (elf_header.e_machine == EM_PARISC)
12711                 addend -= 8;
12712               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12713                         reloc_size);
12714             }
12715           else
12716             byte_put (rloc, addend + sym->st_value, reloc_size);
12717         }
12718
12719       free (symtab);
12720       /* Let the target specific reloc processing code know that
12721          we have finished with these relocs.  */
12722       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12723
12724       if (relocs_return)
12725         {
12726           * (Elf_Internal_Rela **) relocs_return = relocs;
12727           * num_relocs_return = num_relocs;
12728         }
12729       else
12730         free (relocs);
12731
12732       break;
12733     }
12734
12735   return res;
12736 }
12737
12738 #ifdef SUPPORT_DISASSEMBLY
12739 static bfd_boolean
12740 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12741 {
12742   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12743
12744   /* FIXME: XXX -- to be done --- XXX */
12745
12746   return TRUE;
12747 }
12748 #endif
12749
12750 /* Reads in the contents of SECTION from FILE, returning a pointer
12751    to a malloc'ed buffer or NULL if something went wrong.  */
12752
12753 static char *
12754 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12755 {
12756   bfd_size_type num_bytes;
12757
12758   num_bytes = section->sh_size;
12759
12760   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12761     {
12762       printf (_("\nSection '%s' has no data to dump.\n"),
12763               printable_section_name (section));
12764       return NULL;
12765     }
12766
12767   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12768                              _("section contents"));
12769 }
12770
12771 /* Uncompresses a section that was compressed using zlib, in place.  */
12772
12773 static bfd_boolean
12774 uncompress_section_contents (unsigned char **buffer,
12775                              dwarf_size_type uncompressed_size,
12776                              dwarf_size_type *size)
12777 {
12778   dwarf_size_type compressed_size = *size;
12779   unsigned char * compressed_buffer = *buffer;
12780   unsigned char * uncompressed_buffer;
12781   z_stream strm;
12782   int rc;
12783
12784   /* It is possible the section consists of several compressed
12785      buffers concatenated together, so we uncompress in a loop.  */
12786   /* PR 18313: The state field in the z_stream structure is supposed
12787      to be invisible to the user (ie us), but some compilers will
12788      still complain about it being used without initialisation.  So
12789      we first zero the entire z_stream structure and then set the fields
12790      that we need.  */
12791   memset (& strm, 0, sizeof strm);
12792   strm.avail_in = compressed_size;
12793   strm.next_in = (Bytef *) compressed_buffer;
12794   strm.avail_out = uncompressed_size;
12795   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12796
12797   rc = inflateInit (& strm);
12798   while (strm.avail_in > 0)
12799     {
12800       if (rc != Z_OK)
12801         goto fail;
12802       strm.next_out = ((Bytef *) uncompressed_buffer
12803                        + (uncompressed_size - strm.avail_out));
12804       rc = inflate (&strm, Z_FINISH);
12805       if (rc != Z_STREAM_END)
12806         goto fail;
12807       rc = inflateReset (& strm);
12808     }
12809   rc = inflateEnd (& strm);
12810   if (rc != Z_OK
12811       || strm.avail_out != 0)
12812     goto fail;
12813
12814   *buffer = uncompressed_buffer;
12815   *size = uncompressed_size;
12816   return TRUE;
12817
12818  fail:
12819   free (uncompressed_buffer);
12820   /* Indicate decompression failure.  */
12821   *buffer = NULL;
12822   return FALSE;
12823 }
12824
12825 static bfd_boolean
12826 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12827 {
12828   Elf_Internal_Shdr *  relsec;
12829   bfd_size_type        num_bytes;
12830   unsigned char *      data;
12831   unsigned char *      end;
12832   unsigned char *      real_start;
12833   unsigned char *      start;
12834   bfd_boolean          some_strings_shown;
12835
12836   real_start = start = (unsigned char *) get_section_contents (section,
12837                                                                file);
12838   if (start == NULL)
12839     return FALSE;
12840   num_bytes = section->sh_size;
12841
12842   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12843
12844   if (decompress_dumps)
12845     {
12846       dwarf_size_type new_size = num_bytes;
12847       dwarf_size_type uncompressed_size = 0;
12848
12849       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12850         {
12851           Elf_Internal_Chdr chdr;
12852           unsigned int compression_header_size
12853             = get_compression_header (& chdr, (unsigned char *) start,
12854                                       num_bytes);
12855
12856           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12857             {
12858               warn (_("section '%s' has unsupported compress type: %d\n"),
12859                     printable_section_name (section), chdr.ch_type);
12860               return FALSE;
12861             }
12862           else if (chdr.ch_addralign != section->sh_addralign)
12863             {
12864               warn (_("compressed section '%s' is corrupted\n"),
12865                     printable_section_name (section));
12866               return FALSE;
12867             }
12868           uncompressed_size = chdr.ch_size;
12869           start += compression_header_size;
12870           new_size -= compression_header_size;
12871         }
12872       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12873         {
12874           /* Read the zlib header.  In this case, it should be "ZLIB"
12875              followed by the uncompressed section size, 8 bytes in
12876              big-endian order.  */
12877           uncompressed_size = start[4]; uncompressed_size <<= 8;
12878           uncompressed_size += start[5]; uncompressed_size <<= 8;
12879           uncompressed_size += start[6]; uncompressed_size <<= 8;
12880           uncompressed_size += start[7]; uncompressed_size <<= 8;
12881           uncompressed_size += start[8]; uncompressed_size <<= 8;
12882           uncompressed_size += start[9]; uncompressed_size <<= 8;
12883           uncompressed_size += start[10]; uncompressed_size <<= 8;
12884           uncompressed_size += start[11];
12885           start += 12;
12886           new_size -= 12;
12887         }
12888
12889       if (uncompressed_size)
12890         {
12891           if (uncompress_section_contents (& start,
12892                                            uncompressed_size, & new_size))
12893             num_bytes = new_size;
12894           else
12895             {
12896               error (_("Unable to decompress section %s\n"),
12897                      printable_section_name (section));
12898               return FALSE;
12899             }
12900         }
12901       else
12902         start = real_start;
12903     }
12904
12905   /* If the section being dumped has relocations against it the user might
12906      be expecting these relocations to have been applied.  Check for this
12907      case and issue a warning message in order to avoid confusion.
12908      FIXME: Maybe we ought to have an option that dumps a section with
12909      relocs applied ?  */
12910   for (relsec = section_headers;
12911        relsec < section_headers + elf_header.e_shnum;
12912        ++relsec)
12913     {
12914       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12915           || relsec->sh_info >= elf_header.e_shnum
12916           || section_headers + relsec->sh_info != section
12917           || relsec->sh_size == 0
12918           || relsec->sh_link >= elf_header.e_shnum)
12919         continue;
12920
12921       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12922       break;
12923     }
12924
12925   data = start;
12926   end  = start + num_bytes;
12927   some_strings_shown = FALSE;
12928
12929   while (data < end)
12930     {
12931       while (!ISPRINT (* data))
12932         if (++ data >= end)
12933           break;
12934
12935       if (data < end)
12936         {
12937           size_t maxlen = end - data;
12938
12939 #ifndef __MSVCRT__
12940           /* PR 11128: Use two separate invocations in order to work
12941              around bugs in the Solaris 8 implementation of printf.  */
12942           printf ("  [%6tx]  ", data - start);
12943 #else
12944           printf ("  [%6Ix]  ", (size_t) (data - start));
12945 #endif
12946           if (maxlen > 0)
12947             {
12948               print_symbol ((int) maxlen, (const char *) data);
12949               putchar ('\n');
12950               data += strnlen ((const char *) data, maxlen);
12951             }
12952           else
12953             {
12954               printf (_("<corrupt>\n"));
12955               data = end;
12956             }
12957           some_strings_shown = TRUE;
12958         }
12959     }
12960
12961   if (! some_strings_shown)
12962     printf (_("  No strings found in this section."));
12963
12964   free (real_start);
12965
12966   putchar ('\n');
12967   return TRUE;
12968 }
12969
12970 static bfd_boolean
12971 dump_section_as_bytes (Elf_Internal_Shdr * section,
12972                        FILE * file,
12973                        bfd_boolean relocate)
12974 {
12975   Elf_Internal_Shdr * relsec;
12976   bfd_size_type       bytes;
12977   bfd_size_type       section_size;
12978   bfd_vma             addr;
12979   unsigned char *     data;
12980   unsigned char *     real_start;
12981   unsigned char *     start;
12982
12983   real_start = start = (unsigned char *) get_section_contents (section, file);
12984   if (start == NULL)
12985     return FALSE;
12986
12987   section_size = section->sh_size;
12988
12989   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12990
12991   if (decompress_dumps)
12992     {
12993       dwarf_size_type new_size = section_size;
12994       dwarf_size_type uncompressed_size = 0;
12995
12996       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12997         {
12998           Elf_Internal_Chdr chdr;
12999           unsigned int compression_header_size
13000             = get_compression_header (& chdr, start, section_size);
13001
13002           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13003             {
13004               warn (_("section '%s' has unsupported compress type: %d\n"),
13005                     printable_section_name (section), chdr.ch_type);
13006               return FALSE;
13007             }
13008           else if (chdr.ch_addralign != section->sh_addralign)
13009             {
13010               warn (_("compressed section '%s' is corrupted\n"),
13011                     printable_section_name (section));
13012               return FALSE;
13013             }
13014           uncompressed_size = chdr.ch_size;
13015           start += compression_header_size;
13016           new_size -= compression_header_size;
13017         }
13018       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13019         {
13020           /* Read the zlib header.  In this case, it should be "ZLIB"
13021              followed by the uncompressed section size, 8 bytes in
13022              big-endian order.  */
13023           uncompressed_size = start[4]; uncompressed_size <<= 8;
13024           uncompressed_size += start[5]; uncompressed_size <<= 8;
13025           uncompressed_size += start[6]; uncompressed_size <<= 8;
13026           uncompressed_size += start[7]; uncompressed_size <<= 8;
13027           uncompressed_size += start[8]; uncompressed_size <<= 8;
13028           uncompressed_size += start[9]; uncompressed_size <<= 8;
13029           uncompressed_size += start[10]; uncompressed_size <<= 8;
13030           uncompressed_size += start[11];
13031           start += 12;
13032           new_size -= 12;
13033         }
13034
13035       if (uncompressed_size)
13036         {
13037           if (uncompress_section_contents (& start, uncompressed_size,
13038                                            & new_size))
13039             {
13040               section_size = new_size;
13041             }
13042           else
13043             {
13044               error (_("Unable to decompress section %s\n"),
13045                      printable_section_name (section));
13046               /* FIXME: Print the section anyway ?  */
13047               return FALSE;
13048             }
13049         }
13050       else
13051         start = real_start;
13052     }
13053
13054   if (relocate)
13055     {
13056       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13057         return FALSE;
13058     }
13059   else
13060     {
13061       /* If the section being dumped has relocations against it the user might
13062          be expecting these relocations to have been applied.  Check for this
13063          case and issue a warning message in order to avoid confusion.
13064          FIXME: Maybe we ought to have an option that dumps a section with
13065          relocs applied ?  */
13066       for (relsec = section_headers;
13067            relsec < section_headers + elf_header.e_shnum;
13068            ++relsec)
13069         {
13070           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13071               || relsec->sh_info >= elf_header.e_shnum
13072               || section_headers + relsec->sh_info != section
13073               || relsec->sh_size == 0
13074               || relsec->sh_link >= elf_header.e_shnum)
13075             continue;
13076
13077           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13078           break;
13079         }
13080     }
13081
13082   addr = section->sh_addr;
13083   bytes = section_size;
13084   data = start;
13085
13086   while (bytes)
13087     {
13088       int j;
13089       int k;
13090       int lbytes;
13091
13092       lbytes = (bytes > 16 ? 16 : bytes);
13093
13094       printf ("  0x%8.8lx ", (unsigned long) addr);
13095
13096       for (j = 0; j < 16; j++)
13097         {
13098           if (j < lbytes)
13099             printf ("%2.2x", data[j]);
13100           else
13101             printf ("  ");
13102
13103           if ((j & 3) == 3)
13104             printf (" ");
13105         }
13106
13107       for (j = 0; j < lbytes; j++)
13108         {
13109           k = data[j];
13110           if (k >= ' ' && k < 0x7f)
13111             printf ("%c", k);
13112           else
13113             printf (".");
13114         }
13115
13116       putchar ('\n');
13117
13118       data  += lbytes;
13119       addr  += lbytes;
13120       bytes -= lbytes;
13121     }
13122
13123   free (real_start);
13124
13125   putchar ('\n');
13126   return TRUE;
13127 }
13128
13129 static bfd_boolean
13130 load_specific_debug_section (enum dwarf_section_display_enum debug,
13131                              const Elf_Internal_Shdr * sec, void * file)
13132 {
13133   struct dwarf_section * section = &debug_displays [debug].section;
13134   char buf [64];
13135
13136   /* If it is already loaded, do nothing.  */
13137   if (section->start != NULL)
13138     return TRUE;
13139
13140   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13141   section->address = sec->sh_addr;
13142   section->user_data = NULL;
13143   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13144                                                sec->sh_offset, 1,
13145                                                sec->sh_size, buf);
13146   if (section->start == NULL)
13147     section->size = 0;
13148   else
13149     {
13150       unsigned char *start = section->start;
13151       dwarf_size_type size = sec->sh_size;
13152       dwarf_size_type uncompressed_size = 0;
13153
13154       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13155         {
13156           Elf_Internal_Chdr chdr;
13157           unsigned int compression_header_size;
13158
13159           if (size < (is_32bit_elf
13160                       ? sizeof (Elf32_External_Chdr)
13161                       : sizeof (Elf64_External_Chdr)))
13162             {
13163               warn (_("compressed section %s is too small to contain a compression header"),
13164                     section->name);
13165               return FALSE;
13166             }
13167
13168           compression_header_size = get_compression_header (&chdr, start, size);
13169
13170           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13171             {
13172               warn (_("section '%s' has unsupported compress type: %d\n"),
13173                     section->name, chdr.ch_type);
13174               return FALSE;
13175             }
13176           else if (chdr.ch_addralign != sec->sh_addralign)
13177             {
13178               warn (_("compressed section '%s' is corrupted\n"),
13179                     section->name);
13180               return FALSE;
13181             }
13182           uncompressed_size = chdr.ch_size;
13183           start += compression_header_size;
13184           size -= compression_header_size;
13185         }
13186       else if (size > 12 && streq ((char *) start, "ZLIB"))
13187         {
13188           /* Read the zlib header.  In this case, it should be "ZLIB"
13189              followed by the uncompressed section size, 8 bytes in
13190              big-endian order.  */
13191           uncompressed_size = start[4]; uncompressed_size <<= 8;
13192           uncompressed_size += start[5]; uncompressed_size <<= 8;
13193           uncompressed_size += start[6]; uncompressed_size <<= 8;
13194           uncompressed_size += start[7]; uncompressed_size <<= 8;
13195           uncompressed_size += start[8]; uncompressed_size <<= 8;
13196           uncompressed_size += start[9]; uncompressed_size <<= 8;
13197           uncompressed_size += start[10]; uncompressed_size <<= 8;
13198           uncompressed_size += start[11];
13199           start += 12;
13200           size -= 12;
13201         }
13202
13203       if (uncompressed_size)
13204         {
13205           if (uncompress_section_contents (&start, uncompressed_size,
13206                                            &size))
13207             {
13208               /* Free the compressed buffer, update the section buffer
13209                  and the section size if uncompress is successful.  */
13210               free (section->start);
13211               section->start = start;
13212             }
13213           else
13214             {
13215               error (_("Unable to decompress section %s\n"),
13216                      printable_section_name (sec));
13217               return FALSE;
13218             }
13219         }
13220
13221       section->size = size;
13222     }
13223
13224   if (section->start == NULL)
13225     return FALSE;
13226
13227   if (debug_displays [debug].relocate)
13228     {
13229       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13230                                & section->reloc_info, & section->num_relocs))
13231         return FALSE;
13232     }
13233   else
13234     {
13235       section->reloc_info = NULL;
13236       section->num_relocs = 0;
13237     }
13238
13239   return TRUE;
13240 }
13241
13242 /* If this is not NULL, load_debug_section will only look for sections
13243    within the list of sections given here.  */
13244 static unsigned int * section_subset = NULL;
13245
13246 bfd_boolean
13247 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13248 {
13249   struct dwarf_section * section = &debug_displays [debug].section;
13250   Elf_Internal_Shdr * sec;
13251
13252   /* Locate the debug section.  */
13253   sec = find_section_in_set (section->uncompressed_name, section_subset);
13254   if (sec != NULL)
13255     section->name = section->uncompressed_name;
13256   else
13257     {
13258       sec = find_section_in_set (section->compressed_name, section_subset);
13259       if (sec != NULL)
13260         section->name = section->compressed_name;
13261     }
13262   if (sec == NULL)
13263     return FALSE;
13264
13265   /* If we're loading from a subset of sections, and we've loaded
13266      a section matching this name before, it's likely that it's a
13267      different one.  */
13268   if (section_subset != NULL)
13269     free_debug_section (debug);
13270
13271   return load_specific_debug_section (debug, sec, (FILE *) file);
13272 }
13273
13274 void
13275 free_debug_section (enum dwarf_section_display_enum debug)
13276 {
13277   struct dwarf_section * section = &debug_displays [debug].section;
13278
13279   if (section->start == NULL)
13280     return;
13281
13282   free ((char *) section->start);
13283   section->start = NULL;
13284   section->address = 0;
13285   section->size = 0;
13286 }
13287
13288 static bfd_boolean
13289 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13290 {
13291   char * name = SECTION_NAME (section);
13292   const char * print_name = printable_section_name (section);
13293   bfd_size_type length;
13294   bfd_boolean result = TRUE;
13295   int i;
13296
13297   length = section->sh_size;
13298   if (length == 0)
13299     {
13300       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13301       return TRUE;
13302     }
13303   if (section->sh_type == SHT_NOBITS)
13304     {
13305       /* There is no point in dumping the contents of a debugging section
13306          which has the NOBITS type - the bits in the file will be random.
13307          This can happen when a file containing a .eh_frame section is
13308          stripped with the --only-keep-debug command line option.  */
13309       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13310               print_name);
13311       return FALSE;
13312     }
13313
13314   if (const_strneq (name, ".gnu.linkonce.wi."))
13315     name = ".debug_info";
13316
13317   /* See if we know how to display the contents of this section.  */
13318   for (i = 0; i < max; i++)
13319     if (streq (debug_displays[i].section.uncompressed_name, name)
13320         || (i == line && const_strneq (name, ".debug_line."))
13321         || streq (debug_displays[i].section.compressed_name, name))
13322       {
13323         struct dwarf_section * sec = &debug_displays [i].section;
13324         int secondary = (section != find_section (name));
13325
13326         if (secondary)
13327           free_debug_section ((enum dwarf_section_display_enum) i);
13328
13329         if (i == line && const_strneq (name, ".debug_line."))
13330           sec->name = name;
13331         else if (streq (sec->uncompressed_name, name))
13332           sec->name = sec->uncompressed_name;
13333         else
13334           sec->name = sec->compressed_name;
13335         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13336                                          section, file))
13337           {
13338             /* If this debug section is part of a CU/TU set in a .dwp file,
13339                restrict load_debug_section to the sections in that set.  */
13340             section_subset = find_cu_tu_set (file, shndx);
13341
13342             result &= debug_displays[i].display (sec, file);
13343
13344             section_subset = NULL;
13345
13346             if (secondary || (i != info && i != abbrev))
13347               free_debug_section ((enum dwarf_section_display_enum) i);
13348           }
13349
13350         break;
13351       }
13352
13353   if (i == max)
13354     {
13355       printf (_("Unrecognized debug section: %s\n"), print_name);
13356       result = FALSE;
13357     }
13358
13359   return result;
13360 }
13361
13362 /* Set DUMP_SECTS for all sections where dumps were requested
13363    based on section name.  */
13364
13365 static void
13366 initialise_dumps_byname (void)
13367 {
13368   struct dump_list_entry * cur;
13369
13370   for (cur = dump_sects_byname; cur; cur = cur->next)
13371     {
13372       unsigned int i;
13373       bfd_boolean any = FALSE;
13374
13375       for (i = 0; i < elf_header.e_shnum; i++)
13376         if (streq (SECTION_NAME (section_headers + i), cur->name))
13377           {
13378             request_dump_bynumber (i, cur->type);
13379             any = TRUE;
13380           }
13381
13382       if (!any)
13383         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13384               cur->name);
13385     }
13386 }
13387
13388 static bfd_boolean
13389 process_section_contents (FILE * file)
13390 {
13391   Elf_Internal_Shdr * section;
13392   unsigned int i;
13393   bfd_boolean res = TRUE;
13394
13395   if (! do_dump)
13396     return TRUE;
13397
13398   initialise_dumps_byname ();
13399
13400   for (i = 0, section = section_headers;
13401        i < elf_header.e_shnum && i < num_dump_sects;
13402        i++, section++)
13403     {
13404 #ifdef SUPPORT_DISASSEMBLY
13405       if (dump_sects[i] & DISASS_DUMP)
13406         disassemble_section (section, file);
13407 #endif
13408       if (dump_sects[i] & HEX_DUMP)
13409         {
13410           if (! dump_section_as_bytes (section, file, FALSE))
13411             res = FALSE;
13412         }
13413
13414       if (dump_sects[i] & RELOC_DUMP)
13415         {
13416           if (! dump_section_as_bytes (section, file, TRUE))
13417             res = FALSE;
13418         }
13419
13420       if (dump_sects[i] & STRING_DUMP)
13421         {
13422           if (! dump_section_as_strings (section, file))
13423             res = FALSE;
13424         }
13425
13426       if (dump_sects[i] & DEBUG_DUMP)
13427         {
13428           if (! display_debug_section (i, section, file))
13429             res = FALSE;
13430         }
13431     }
13432
13433   /* Check to see if the user requested a
13434      dump of a section that does not exist.  */
13435   while (i < num_dump_sects)
13436     {
13437       if (dump_sects[i])
13438         {
13439           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13440           res = FALSE;
13441         }
13442       i++;
13443     }
13444
13445   return res;
13446 }
13447
13448 static void
13449 process_mips_fpe_exception (int mask)
13450 {
13451   if (mask)
13452     {
13453       bfd_boolean first = TRUE;
13454
13455       if (mask & OEX_FPU_INEX)
13456         fputs ("INEX", stdout), first = FALSE;
13457       if (mask & OEX_FPU_UFLO)
13458         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13459       if (mask & OEX_FPU_OFLO)
13460         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13461       if (mask & OEX_FPU_DIV0)
13462         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13463       if (mask & OEX_FPU_INVAL)
13464         printf ("%sINVAL", first ? "" : "|");
13465     }
13466   else
13467     fputs ("0", stdout);
13468 }
13469
13470 /* Display's the value of TAG at location P.  If TAG is
13471    greater than 0 it is assumed to be an unknown tag, and
13472    a message is printed to this effect.  Otherwise it is
13473    assumed that a message has already been printed.
13474
13475    If the bottom bit of TAG is set it assumed to have a
13476    string value, otherwise it is assumed to have an integer
13477    value.
13478
13479    Returns an updated P pointing to the first unread byte
13480    beyond the end of TAG's value.
13481
13482    Reads at or beyond END will not be made.  */
13483
13484 static unsigned char *
13485 display_tag_value (signed int tag,
13486                    unsigned char * p,
13487                    const unsigned char * const end)
13488 {
13489   unsigned long val;
13490
13491   if (tag > 0)
13492     printf ("  Tag_unknown_%d: ", tag);
13493
13494   if (p >= end)
13495     {
13496       warn (_("<corrupt tag>\n"));
13497     }
13498   else if (tag & 1)
13499     {
13500       /* PR 17531 file: 027-19978-0.004.  */
13501       size_t maxlen = (end - p) - 1;
13502
13503       putchar ('"');
13504       if (maxlen > 0)
13505         {
13506           print_symbol ((int) maxlen, (const char *) p);
13507           p += strnlen ((char *) p, maxlen) + 1;
13508         }
13509       else
13510         {
13511           printf (_("<corrupt string tag>"));
13512           p = (unsigned char *) end;
13513         }
13514       printf ("\"\n");
13515     }
13516   else
13517     {
13518       unsigned int len;
13519
13520       val = read_uleb128 (p, &len, end);
13521       p += len;
13522       printf ("%ld (0x%lx)\n", val, val);
13523     }
13524
13525   assert (p <= end);
13526   return p;
13527 }
13528
13529 /* ARC ABI attributes section.  */
13530
13531 static unsigned char *
13532 display_arc_attribute (unsigned char * p,
13533                        const unsigned char * const end)
13534 {
13535   unsigned int tag;
13536   unsigned int len;
13537   unsigned int val;
13538
13539   tag = read_uleb128 (p, &len, end);
13540   p += len;
13541
13542   switch (tag)
13543     {
13544     case Tag_ARC_PCS_config:
13545       val = read_uleb128 (p, &len, end);
13546       p += len;
13547       printf ("  Tag_ARC_PCS_config: ");
13548       switch (val)
13549         {
13550         case 0:
13551           printf (_("Absent/Non standard\n"));
13552           break;
13553         case 1:
13554           printf (_("Bare metal/mwdt\n"));
13555           break;
13556         case 2:
13557           printf (_("Bare metal/newlib\n"));
13558           break;
13559         case 3:
13560           printf (_("Linux/uclibc\n"));
13561           break;
13562         case 4:
13563           printf (_("Linux/glibc\n"));
13564           break;
13565         default:
13566           printf (_("Unknown\n"));
13567           break;
13568         }
13569       break;
13570
13571     case Tag_ARC_CPU_base:
13572       val = read_uleb128 (p, &len, end);
13573       p += len;
13574       printf ("  Tag_ARC_CPU_base: ");
13575       switch (val)
13576         {
13577         default:
13578         case TAG_CPU_NONE:
13579           printf (_("Absent\n"));
13580           break;
13581         case TAG_CPU_ARC6xx:
13582           printf ("ARC6xx\n");
13583           break;
13584         case TAG_CPU_ARC7xx:
13585           printf ("ARC7xx\n");
13586           break;
13587         case TAG_CPU_ARCEM:
13588           printf ("ARCEM\n");
13589           break;
13590         case TAG_CPU_ARCHS:
13591           printf ("ARCHS\n");
13592           break;
13593         }
13594       break;
13595
13596     case Tag_ARC_CPU_variation:
13597       val = read_uleb128 (p, &len, end);
13598       p += len;
13599       printf ("  Tag_ARC_CPU_variation: ");
13600       switch (val)
13601         {
13602         default:
13603           if (val > 0 && val < 16)
13604               printf ("Core%d\n", val);
13605           else
13606               printf ("Unknown\n");
13607           break;
13608
13609         case 0:
13610           printf (_("Absent\n"));
13611           break;
13612         }
13613       break;
13614
13615     case Tag_ARC_CPU_name:
13616       printf ("  Tag_ARC_CPU_name: ");
13617       p = display_tag_value (-1, p, end);
13618       break;
13619
13620     case Tag_ARC_ABI_rf16:
13621       val = read_uleb128 (p, &len, end);
13622       p += len;
13623       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13624       break;
13625
13626     case Tag_ARC_ABI_osver:
13627       val = read_uleb128 (p, &len, end);
13628       p += len;
13629       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13630       break;
13631
13632     case Tag_ARC_ABI_pic:
13633     case Tag_ARC_ABI_sda:
13634       val = read_uleb128 (p, &len, end);
13635       p += len;
13636       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13637               : "  Tag_ARC_ABI_pic: ");
13638       switch (val)
13639         {
13640         case 0:
13641           printf (_("Absent\n"));
13642           break;
13643         case 1:
13644           printf ("MWDT\n");
13645           break;
13646         case 2:
13647           printf ("GNU\n");
13648           break;
13649         default:
13650           printf (_("Unknown\n"));
13651           break;
13652         }
13653       break;
13654
13655     case Tag_ARC_ABI_tls:
13656       val = read_uleb128 (p, &len, end);
13657       p += len;
13658       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13659       break;
13660
13661     case Tag_ARC_ABI_enumsize:
13662       val = read_uleb128 (p, &len, end);
13663       p += len;
13664       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13665               _("smallest"));
13666       break;
13667
13668     case Tag_ARC_ABI_exceptions:
13669       val = read_uleb128 (p, &len, end);
13670       p += len;
13671       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13672               : _("default"));
13673       break;
13674
13675     case Tag_ARC_ABI_double_size:
13676       val = read_uleb128 (p, &len, end);
13677       p += len;
13678       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13679       break;
13680
13681     case Tag_ARC_ISA_config:
13682       printf ("  Tag_ARC_ISA_config: ");
13683       p = display_tag_value (-1, p, end);
13684       break;
13685
13686     case Tag_ARC_ISA_apex:
13687       printf ("  Tag_ARC_ISA_apex: ");
13688       p = display_tag_value (-1, p, end);
13689       break;
13690
13691     case Tag_ARC_ISA_mpy_option:
13692       val = read_uleb128 (p, &len, end);
13693       p += len;
13694       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13695       break;
13696
13697     default:
13698       return display_tag_value (tag & 1, p, end);
13699     }
13700
13701   return p;
13702 }
13703
13704 /* ARM EABI attributes section.  */
13705 typedef struct
13706 {
13707   unsigned int tag;
13708   const char * name;
13709   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13710   unsigned int type;
13711   const char ** table;
13712 } arm_attr_public_tag;
13713
13714 static const char * arm_attr_tag_CPU_arch[] =
13715   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13716    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13717    "v8-M.mainline"};
13718 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13719 static const char * arm_attr_tag_THUMB_ISA_use[] =
13720   {"No", "Thumb-1", "Thumb-2", "Yes"};
13721 static const char * arm_attr_tag_FP_arch[] =
13722   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13723    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13724 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13725 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13726   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13727    "NEON for ARMv8.1"};
13728 static const char * arm_attr_tag_PCS_config[] =
13729   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13730    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13731 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13732   {"V6", "SB", "TLS", "Unused"};
13733 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13734   {"Absolute", "PC-relative", "SB-relative", "None"};
13735 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13736   {"Absolute", "PC-relative", "None"};
13737 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13738   {"None", "direct", "GOT-indirect"};
13739 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13740   {"None", "??? 1", "2", "??? 3", "4"};
13741 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13742 static const char * arm_attr_tag_ABI_FP_denormal[] =
13743   {"Unused", "Needed", "Sign only"};
13744 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13745 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13746 static const char * arm_attr_tag_ABI_FP_number_model[] =
13747   {"Unused", "Finite", "RTABI", "IEEE 754"};
13748 static const char * arm_attr_tag_ABI_enum_size[] =
13749   {"Unused", "small", "int", "forced to int"};
13750 static const char * arm_attr_tag_ABI_HardFP_use[] =
13751   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13752 static const char * arm_attr_tag_ABI_VFP_args[] =
13753   {"AAPCS", "VFP registers", "custom", "compatible"};
13754 static const char * arm_attr_tag_ABI_WMMX_args[] =
13755   {"AAPCS", "WMMX registers", "custom"};
13756 static const char * arm_attr_tag_ABI_optimization_goals[] =
13757   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13758     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13759 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13760   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13761     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13762 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13763 static const char * arm_attr_tag_FP_HP_extension[] =
13764   {"Not Allowed", "Allowed"};
13765 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13766   {"None", "IEEE 754", "Alternative Format"};
13767 static const char * arm_attr_tag_DSP_extension[] =
13768   {"Follow architecture", "Allowed"};
13769 static const char * arm_attr_tag_MPextension_use[] =
13770   {"Not Allowed", "Allowed"};
13771 static const char * arm_attr_tag_DIV_use[] =
13772   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13773     "Allowed in v7-A with integer division extension"};
13774 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13775 static const char * arm_attr_tag_Virtualization_use[] =
13776   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13777     "TrustZone and Virtualization Extensions"};
13778 static const char * arm_attr_tag_MPextension_use_legacy[] =
13779   {"Not Allowed", "Allowed"};
13780
13781 #define LOOKUP(id, name) \
13782   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13783 static arm_attr_public_tag arm_attr_public_tags[] =
13784 {
13785   {4, "CPU_raw_name", 1, NULL},
13786   {5, "CPU_name", 1, NULL},
13787   LOOKUP(6, CPU_arch),
13788   {7, "CPU_arch_profile", 0, NULL},
13789   LOOKUP(8, ARM_ISA_use),
13790   LOOKUP(9, THUMB_ISA_use),
13791   LOOKUP(10, FP_arch),
13792   LOOKUP(11, WMMX_arch),
13793   LOOKUP(12, Advanced_SIMD_arch),
13794   LOOKUP(13, PCS_config),
13795   LOOKUP(14, ABI_PCS_R9_use),
13796   LOOKUP(15, ABI_PCS_RW_data),
13797   LOOKUP(16, ABI_PCS_RO_data),
13798   LOOKUP(17, ABI_PCS_GOT_use),
13799   LOOKUP(18, ABI_PCS_wchar_t),
13800   LOOKUP(19, ABI_FP_rounding),
13801   LOOKUP(20, ABI_FP_denormal),
13802   LOOKUP(21, ABI_FP_exceptions),
13803   LOOKUP(22, ABI_FP_user_exceptions),
13804   LOOKUP(23, ABI_FP_number_model),
13805   {24, "ABI_align_needed", 0, NULL},
13806   {25, "ABI_align_preserved", 0, NULL},
13807   LOOKUP(26, ABI_enum_size),
13808   LOOKUP(27, ABI_HardFP_use),
13809   LOOKUP(28, ABI_VFP_args),
13810   LOOKUP(29, ABI_WMMX_args),
13811   LOOKUP(30, ABI_optimization_goals),
13812   LOOKUP(31, ABI_FP_optimization_goals),
13813   {32, "compatibility", 0, NULL},
13814   LOOKUP(34, CPU_unaligned_access),
13815   LOOKUP(36, FP_HP_extension),
13816   LOOKUP(38, ABI_FP_16bit_format),
13817   LOOKUP(42, MPextension_use),
13818   LOOKUP(44, DIV_use),
13819   LOOKUP(46, DSP_extension),
13820   {64, "nodefaults", 0, NULL},
13821   {65, "also_compatible_with", 0, NULL},
13822   LOOKUP(66, T2EE_use),
13823   {67, "conformance", 1, NULL},
13824   LOOKUP(68, Virtualization_use),
13825   LOOKUP(70, MPextension_use_legacy)
13826 };
13827 #undef LOOKUP
13828
13829 static unsigned char *
13830 display_arm_attribute (unsigned char * p,
13831                        const unsigned char * const end)
13832 {
13833   unsigned int tag;
13834   unsigned int len;
13835   unsigned int val;
13836   arm_attr_public_tag * attr;
13837   unsigned i;
13838   unsigned int type;
13839
13840   tag = read_uleb128 (p, &len, end);
13841   p += len;
13842   attr = NULL;
13843   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13844     {
13845       if (arm_attr_public_tags[i].tag == tag)
13846         {
13847           attr = &arm_attr_public_tags[i];
13848           break;
13849         }
13850     }
13851
13852   if (attr)
13853     {
13854       printf ("  Tag_%s: ", attr->name);
13855       switch (attr->type)
13856         {
13857         case 0:
13858           switch (tag)
13859             {
13860             case 7: /* Tag_CPU_arch_profile.  */
13861               val = read_uleb128 (p, &len, end);
13862               p += len;
13863               switch (val)
13864                 {
13865                 case 0: printf (_("None\n")); break;
13866                 case 'A': printf (_("Application\n")); break;
13867                 case 'R': printf (_("Realtime\n")); break;
13868                 case 'M': printf (_("Microcontroller\n")); break;
13869                 case 'S': printf (_("Application or Realtime\n")); break;
13870                 default: printf ("??? (%d)\n", val); break;
13871                 }
13872               break;
13873
13874             case 24: /* Tag_align_needed.  */
13875               val = read_uleb128 (p, &len, end);
13876               p += len;
13877               switch (val)
13878                 {
13879                 case 0: printf (_("None\n")); break;
13880                 case 1: printf (_("8-byte\n")); break;
13881                 case 2: printf (_("4-byte\n")); break;
13882                 case 3: printf ("??? 3\n"); break;
13883                 default:
13884                   if (val <= 12)
13885                     printf (_("8-byte and up to %d-byte extended\n"),
13886                             1 << val);
13887                   else
13888                     printf ("??? (%d)\n", val);
13889                   break;
13890                 }
13891               break;
13892
13893             case 25: /* Tag_align_preserved.  */
13894               val = read_uleb128 (p, &len, end);
13895               p += len;
13896               switch (val)
13897                 {
13898                 case 0: printf (_("None\n")); break;
13899                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13900                 case 2: printf (_("8-byte\n")); break;
13901                 case 3: printf ("??? 3\n"); break;
13902                 default:
13903                   if (val <= 12)
13904                     printf (_("8-byte and up to %d-byte extended\n"),
13905                             1 << val);
13906                   else
13907                     printf ("??? (%d)\n", val);
13908                   break;
13909                 }
13910               break;
13911
13912             case 32: /* Tag_compatibility.  */
13913               {
13914                 val = read_uleb128 (p, &len, end);
13915                 p += len;
13916                 printf (_("flag = %d, vendor = "), val);
13917                 if (p < end - 1)
13918                   {
13919                     size_t maxlen = (end - p) - 1;
13920
13921                     print_symbol ((int) maxlen, (const char *) p);
13922                     p += strnlen ((char *) p, maxlen) + 1;
13923                   }
13924                 else
13925                   {
13926                     printf (_("<corrupt>"));
13927                     p = (unsigned char *) end;
13928                   }
13929                 putchar ('\n');
13930               }
13931               break;
13932
13933             case 64: /* Tag_nodefaults.  */
13934               /* PR 17531: file: 001-505008-0.01.  */
13935               if (p < end)
13936                 p++;
13937               printf (_("True\n"));
13938               break;
13939
13940             case 65: /* Tag_also_compatible_with.  */
13941               val = read_uleb128 (p, &len, end);
13942               p += len;
13943               if (val == 6 /* Tag_CPU_arch.  */)
13944                 {
13945                   val = read_uleb128 (p, &len, end);
13946                   p += len;
13947                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13948                     printf ("??? (%d)\n", val);
13949                   else
13950                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13951                 }
13952               else
13953                 printf ("???\n");
13954               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13955                 ;
13956               break;
13957
13958             default:
13959               printf (_("<unknown: %d>\n"), tag);
13960               break;
13961             }
13962           return p;
13963
13964         case 1:
13965           return display_tag_value (-1, p, end);
13966         case 2:
13967           return display_tag_value (0, p, end);
13968
13969         default:
13970           assert (attr->type & 0x80);
13971           val = read_uleb128 (p, &len, end);
13972           p += len;
13973           type = attr->type & 0x7f;
13974           if (val >= type)
13975             printf ("??? (%d)\n", val);
13976           else
13977             printf ("%s\n", attr->table[val]);
13978           return p;
13979         }
13980     }
13981
13982   return display_tag_value (tag, p, end);
13983 }
13984
13985 static unsigned char *
13986 display_gnu_attribute (unsigned char * p,
13987                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13988                        const unsigned char * const end)
13989 {
13990   int tag;
13991   unsigned int len;
13992   unsigned int val;
13993
13994   tag = read_uleb128 (p, &len, end);
13995   p += len;
13996
13997   /* Tag_compatibility is the only generic GNU attribute defined at
13998      present.  */
13999   if (tag == 32)
14000     {
14001       val = read_uleb128 (p, &len, end);
14002       p += len;
14003
14004       printf (_("flag = %d, vendor = "), val);
14005       if (p == end)
14006         {
14007           printf (_("<corrupt>\n"));
14008           warn (_("corrupt vendor attribute\n"));
14009         }
14010       else
14011         {
14012           if (p < end - 1)
14013             {
14014               size_t maxlen = (end - p) - 1;
14015
14016               print_symbol ((int) maxlen, (const char *) p);
14017               p += strnlen ((char *) p, maxlen) + 1;
14018             }
14019           else
14020             {
14021               printf (_("<corrupt>"));
14022               p = (unsigned char *) end;
14023             }
14024           putchar ('\n');
14025         }
14026       return p;
14027     }
14028
14029   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14030     return display_proc_gnu_attribute (p, tag, end);
14031
14032   return display_tag_value (tag, p, end);
14033 }
14034
14035 static unsigned char *
14036 display_power_gnu_attribute (unsigned char * p,
14037                              unsigned int tag,
14038                              const unsigned char * const end)
14039 {
14040   unsigned int len;
14041   unsigned int val;
14042
14043   if (tag == Tag_GNU_Power_ABI_FP)
14044     {
14045       val = read_uleb128 (p, &len, end);
14046       p += len;
14047       printf ("  Tag_GNU_Power_ABI_FP: ");
14048       if (len == 0)
14049         {
14050           printf (_("<corrupt>\n"));
14051           return p;
14052         }
14053
14054       if (val > 15)
14055         printf ("(%#x), ", val);
14056
14057       switch (val & 3)
14058         {
14059         case 0:
14060           printf (_("unspecified hard/soft float, "));
14061           break;
14062         case 1:
14063           printf (_("hard float, "));
14064           break;
14065         case 2:
14066           printf (_("soft float, "));
14067           break;
14068         case 3:
14069           printf (_("single-precision hard float, "));
14070           break;
14071         }
14072
14073       switch (val & 0xC)
14074         {
14075         case 0:
14076           printf (_("unspecified long double\n"));
14077           break;
14078         case 4:
14079           printf (_("128-bit IBM long double\n"));
14080           break;
14081         case 8:
14082           printf (_("64-bit long double\n"));
14083           break;
14084         case 12:
14085           printf (_("128-bit IEEE long double\n"));
14086           break;
14087         }
14088       return p;
14089     }
14090
14091   if (tag == Tag_GNU_Power_ABI_Vector)
14092     {
14093       val = read_uleb128 (p, &len, end);
14094       p += len;
14095       printf ("  Tag_GNU_Power_ABI_Vector: ");
14096       if (len == 0)
14097         {
14098           printf (_("<corrupt>\n"));
14099           return p;
14100         }
14101
14102       if (val > 3)
14103         printf ("(%#x), ", val);
14104
14105       switch (val & 3)
14106         {
14107         case 0:
14108           printf (_("unspecified\n"));
14109           break;
14110         case 1:
14111           printf (_("generic\n"));
14112           break;
14113         case 2:
14114           printf ("AltiVec\n");
14115           break;
14116         case 3:
14117           printf ("SPE\n");
14118           break;
14119         }
14120       return p;
14121     }
14122
14123   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14124     {
14125       val = read_uleb128 (p, &len, end);
14126       p += len;
14127       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14128       if (len == 0)
14129         {
14130           printf (_("<corrupt>\n"));
14131           return p;
14132         }
14133
14134       if (val > 2)
14135         printf ("(%#x), ", val);
14136
14137       switch (val & 3)
14138         {
14139         case 0:
14140           printf (_("unspecified\n"));
14141           break;
14142         case 1:
14143           printf ("r3/r4\n");
14144           break;
14145         case 2:
14146           printf (_("memory\n"));
14147           break;
14148         case 3:
14149           printf ("???\n");
14150           break;
14151         }
14152       return p;
14153     }
14154
14155   return display_tag_value (tag & 1, p, end);
14156 }
14157
14158 static unsigned char *
14159 display_s390_gnu_attribute (unsigned char * p,
14160                             unsigned int tag,
14161                             const unsigned char * const end)
14162 {
14163   unsigned int len;
14164   int val;
14165
14166   if (tag == Tag_GNU_S390_ABI_Vector)
14167     {
14168       val = read_uleb128 (p, &len, end);
14169       p += len;
14170       printf ("  Tag_GNU_S390_ABI_Vector: ");
14171
14172       switch (val)
14173         {
14174         case 0:
14175           printf (_("any\n"));
14176           break;
14177         case 1:
14178           printf (_("software\n"));
14179           break;
14180         case 2:
14181           printf (_("hardware\n"));
14182           break;
14183         default:
14184           printf ("??? (%d)\n", val);
14185           break;
14186         }
14187       return p;
14188    }
14189
14190   return display_tag_value (tag & 1, p, end);
14191 }
14192
14193 static void
14194 display_sparc_hwcaps (unsigned int mask)
14195 {
14196   if (mask)
14197     {
14198       bfd_boolean first = TRUE;
14199
14200       if (mask & ELF_SPARC_HWCAP_MUL32)
14201         fputs ("mul32", stdout), first = FALSE;
14202       if (mask & ELF_SPARC_HWCAP_DIV32)
14203         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14204       if (mask & ELF_SPARC_HWCAP_FSMULD)
14205         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14206       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14207         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14208       if (mask & ELF_SPARC_HWCAP_POPC)
14209         printf ("%spopc", first ? "" : "|"), first = FALSE;
14210       if (mask & ELF_SPARC_HWCAP_VIS)
14211         printf ("%svis", first ? "" : "|"), first = FALSE;
14212       if (mask & ELF_SPARC_HWCAP_VIS2)
14213         printf ("%svis2", first ? "" : "|"), first = FALSE;
14214       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14215         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14216       if (mask & ELF_SPARC_HWCAP_FMAF)
14217         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14218       if (mask & ELF_SPARC_HWCAP_VIS3)
14219         printf ("%svis3", first ? "" : "|"), first = FALSE;
14220       if (mask & ELF_SPARC_HWCAP_HPC)
14221         printf ("%shpc", first ? "" : "|"), first = FALSE;
14222       if (mask & ELF_SPARC_HWCAP_RANDOM)
14223         printf ("%srandom", first ? "" : "|"), first = FALSE;
14224       if (mask & ELF_SPARC_HWCAP_TRANS)
14225         printf ("%strans", first ? "" : "|"), first = FALSE;
14226       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14227         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14228       if (mask & ELF_SPARC_HWCAP_IMA)
14229         printf ("%sima", first ? "" : "|"), first = FALSE;
14230       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14231         printf ("%scspare", first ? "" : "|"), first = FALSE;
14232     }
14233   else
14234     fputc ('0', stdout);
14235   fputc ('\n', stdout);
14236 }
14237
14238 static void
14239 display_sparc_hwcaps2 (unsigned int mask)
14240 {
14241   if (mask)
14242     {
14243       bfd_boolean first = TRUE;
14244
14245       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14246         fputs ("fjathplus", stdout), first = FALSE;
14247       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14248         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14249       if (mask & ELF_SPARC_HWCAP2_ADP)
14250         printf ("%sadp", first ? "" : "|"), first = FALSE;
14251       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14252         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14253       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14254         printf ("%smwait", first ? "" : "|"), first = FALSE;
14255       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14256         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14257       if (mask & ELF_SPARC_HWCAP2_XMONT)
14258         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14259       if (mask & ELF_SPARC_HWCAP2_NSEC)
14260         printf ("%snsec", first ? "" : "|"), first = FALSE;
14261       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14262         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14263       if (mask & ELF_SPARC_HWCAP2_FJDES)
14264         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14265       if (mask & ELF_SPARC_HWCAP2_FJAES)
14266         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14267     }
14268   else
14269     fputc ('0', stdout);
14270   fputc ('\n', stdout);
14271 }
14272
14273 static unsigned char *
14274 display_sparc_gnu_attribute (unsigned char * p,
14275                              unsigned int tag,
14276                              const unsigned char * const end)
14277 {
14278   unsigned int len;
14279   int val;
14280
14281   if (tag == Tag_GNU_Sparc_HWCAPS)
14282     {
14283       val = read_uleb128 (p, &len, end);
14284       p += len;
14285       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14286       display_sparc_hwcaps (val);
14287       return p;
14288     }
14289   if (tag == Tag_GNU_Sparc_HWCAPS2)
14290     {
14291       val = read_uleb128 (p, &len, end);
14292       p += len;
14293       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14294       display_sparc_hwcaps2 (val);
14295       return p;
14296     }
14297
14298   return display_tag_value (tag, p, end);
14299 }
14300
14301 static void
14302 print_mips_fp_abi_value (unsigned int val)
14303 {
14304   switch (val)
14305     {
14306     case Val_GNU_MIPS_ABI_FP_ANY:
14307       printf (_("Hard or soft float\n"));
14308       break;
14309     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14310       printf (_("Hard float (double precision)\n"));
14311       break;
14312     case Val_GNU_MIPS_ABI_FP_SINGLE:
14313       printf (_("Hard float (single precision)\n"));
14314       break;
14315     case Val_GNU_MIPS_ABI_FP_SOFT:
14316       printf (_("Soft float\n"));
14317       break;
14318     case Val_GNU_MIPS_ABI_FP_OLD_64:
14319       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14320       break;
14321     case Val_GNU_MIPS_ABI_FP_XX:
14322       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14323       break;
14324     case Val_GNU_MIPS_ABI_FP_64:
14325       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14326       break;
14327     case Val_GNU_MIPS_ABI_FP_64A:
14328       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14329       break;
14330     case Val_GNU_MIPS_ABI_FP_NAN2008:
14331       printf (_("NaN 2008 compatibility\n"));
14332       break;
14333     default:
14334       printf ("??? (%d)\n", val);
14335       break;
14336     }
14337 }
14338
14339 static unsigned char *
14340 display_mips_gnu_attribute (unsigned char * p,
14341                             unsigned int tag,
14342                             const unsigned char * const end)
14343 {
14344   if (tag == Tag_GNU_MIPS_ABI_FP)
14345     {
14346       unsigned int len;
14347       unsigned int val;
14348
14349       val = read_uleb128 (p, &len, end);
14350       p += len;
14351       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14352
14353       print_mips_fp_abi_value (val);
14354
14355       return p;
14356    }
14357
14358   if (tag == Tag_GNU_MIPS_ABI_MSA)
14359     {
14360       unsigned int len;
14361       unsigned int val;
14362
14363       val = read_uleb128 (p, &len, end);
14364       p += len;
14365       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14366
14367       switch (val)
14368         {
14369         case Val_GNU_MIPS_ABI_MSA_ANY:
14370           printf (_("Any MSA or not\n"));
14371           break;
14372         case Val_GNU_MIPS_ABI_MSA_128:
14373           printf (_("128-bit MSA\n"));
14374           break;
14375         default:
14376           printf ("??? (%d)\n", val);
14377           break;
14378         }
14379       return p;
14380     }
14381
14382   return display_tag_value (tag & 1, p, end);
14383 }
14384
14385 static unsigned char *
14386 display_tic6x_attribute (unsigned char * p,
14387                          const unsigned char * const end)
14388 {
14389   unsigned int tag;
14390   unsigned int len;
14391   int val;
14392
14393   tag = read_uleb128 (p, &len, end);
14394   p += len;
14395
14396   switch (tag)
14397     {
14398     case Tag_ISA:
14399       val = read_uleb128 (p, &len, end);
14400       p += len;
14401       printf ("  Tag_ISA: ");
14402
14403       switch (val)
14404         {
14405         case C6XABI_Tag_ISA_none:
14406           printf (_("None\n"));
14407           break;
14408         case C6XABI_Tag_ISA_C62X:
14409           printf ("C62x\n");
14410           break;
14411         case C6XABI_Tag_ISA_C67X:
14412           printf ("C67x\n");
14413           break;
14414         case C6XABI_Tag_ISA_C67XP:
14415           printf ("C67x+\n");
14416           break;
14417         case C6XABI_Tag_ISA_C64X:
14418           printf ("C64x\n");
14419           break;
14420         case C6XABI_Tag_ISA_C64XP:
14421           printf ("C64x+\n");
14422           break;
14423         case C6XABI_Tag_ISA_C674X:
14424           printf ("C674x\n");
14425           break;
14426         default:
14427           printf ("??? (%d)\n", val);
14428           break;
14429         }
14430       return p;
14431
14432     case Tag_ABI_wchar_t:
14433       val = read_uleb128 (p, &len, end);
14434       p += len;
14435       printf ("  Tag_ABI_wchar_t: ");
14436       switch (val)
14437         {
14438         case 0:
14439           printf (_("Not used\n"));
14440           break;
14441         case 1:
14442           printf (_("2 bytes\n"));
14443           break;
14444         case 2:
14445           printf (_("4 bytes\n"));
14446           break;
14447         default:
14448           printf ("??? (%d)\n", val);
14449           break;
14450         }
14451       return p;
14452
14453     case Tag_ABI_stack_align_needed:
14454       val = read_uleb128 (p, &len, end);
14455       p += len;
14456       printf ("  Tag_ABI_stack_align_needed: ");
14457       switch (val)
14458         {
14459         case 0:
14460           printf (_("8-byte\n"));
14461           break;
14462         case 1:
14463           printf (_("16-byte\n"));
14464           break;
14465         default:
14466           printf ("??? (%d)\n", val);
14467           break;
14468         }
14469       return p;
14470
14471     case Tag_ABI_stack_align_preserved:
14472       val = read_uleb128 (p, &len, end);
14473       p += len;
14474       printf ("  Tag_ABI_stack_align_preserved: ");
14475       switch (val)
14476         {
14477         case 0:
14478           printf (_("8-byte\n"));
14479           break;
14480         case 1:
14481           printf (_("16-byte\n"));
14482           break;
14483         default:
14484           printf ("??? (%d)\n", val);
14485           break;
14486         }
14487       return p;
14488
14489     case Tag_ABI_DSBT:
14490       val = read_uleb128 (p, &len, end);
14491       p += len;
14492       printf ("  Tag_ABI_DSBT: ");
14493       switch (val)
14494         {
14495         case 0:
14496           printf (_("DSBT addressing not used\n"));
14497           break;
14498         case 1:
14499           printf (_("DSBT addressing used\n"));
14500           break;
14501         default:
14502           printf ("??? (%d)\n", val);
14503           break;
14504         }
14505       return p;
14506
14507     case Tag_ABI_PID:
14508       val = read_uleb128 (p, &len, end);
14509       p += len;
14510       printf ("  Tag_ABI_PID: ");
14511       switch (val)
14512         {
14513         case 0:
14514           printf (_("Data addressing position-dependent\n"));
14515           break;
14516         case 1:
14517           printf (_("Data addressing position-independent, GOT near DP\n"));
14518           break;
14519         case 2:
14520           printf (_("Data addressing position-independent, GOT far from DP\n"));
14521           break;
14522         default:
14523           printf ("??? (%d)\n", val);
14524           break;
14525         }
14526       return p;
14527
14528     case Tag_ABI_PIC:
14529       val = read_uleb128 (p, &len, end);
14530       p += len;
14531       printf ("  Tag_ABI_PIC: ");
14532       switch (val)
14533         {
14534         case 0:
14535           printf (_("Code addressing position-dependent\n"));
14536           break;
14537         case 1:
14538           printf (_("Code addressing position-independent\n"));
14539           break;
14540         default:
14541           printf ("??? (%d)\n", val);
14542           break;
14543         }
14544       return p;
14545
14546     case Tag_ABI_array_object_alignment:
14547       val = read_uleb128 (p, &len, end);
14548       p += len;
14549       printf ("  Tag_ABI_array_object_alignment: ");
14550       switch (val)
14551         {
14552         case 0:
14553           printf (_("8-byte\n"));
14554           break;
14555         case 1:
14556           printf (_("4-byte\n"));
14557           break;
14558         case 2:
14559           printf (_("16-byte\n"));
14560           break;
14561         default:
14562           printf ("??? (%d)\n", val);
14563           break;
14564         }
14565       return p;
14566
14567     case Tag_ABI_array_object_align_expected:
14568       val = read_uleb128 (p, &len, end);
14569       p += len;
14570       printf ("  Tag_ABI_array_object_align_expected: ");
14571       switch (val)
14572         {
14573         case 0:
14574           printf (_("8-byte\n"));
14575           break;
14576         case 1:
14577           printf (_("4-byte\n"));
14578           break;
14579         case 2:
14580           printf (_("16-byte\n"));
14581           break;
14582         default:
14583           printf ("??? (%d)\n", val);
14584           break;
14585         }
14586       return p;
14587
14588     case Tag_ABI_compatibility:
14589       {
14590         val = read_uleb128 (p, &len, end);
14591         p += len;
14592         printf ("  Tag_ABI_compatibility: ");
14593         printf (_("flag = %d, vendor = "), val);
14594         if (p < end - 1)
14595           {
14596             size_t maxlen = (end - p) - 1;
14597
14598             print_symbol ((int) maxlen, (const char *) p);
14599             p += strnlen ((char *) p, maxlen) + 1;
14600           }
14601         else
14602           {
14603             printf (_("<corrupt>"));
14604             p = (unsigned char *) end;
14605           }
14606         putchar ('\n');
14607         return p;
14608       }
14609
14610     case Tag_ABI_conformance:
14611       {
14612         printf ("  Tag_ABI_conformance: \"");
14613         if (p < end - 1)
14614           {
14615             size_t maxlen = (end - p) - 1;
14616
14617             print_symbol ((int) maxlen, (const char *) p);
14618             p += strnlen ((char *) p, maxlen) + 1;
14619           }
14620         else
14621           {
14622             printf (_("<corrupt>"));
14623             p = (unsigned char *) end;
14624           }
14625         printf ("\"\n");
14626         return p;
14627       }
14628     }
14629
14630   return display_tag_value (tag, p, end);
14631 }
14632
14633 static void
14634 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14635 {
14636   unsigned long addr = 0;
14637   size_t bytes = end - p;
14638
14639   assert (end > p);
14640   while (bytes)
14641     {
14642       int j;
14643       int k;
14644       int lbytes = (bytes > 16 ? 16 : bytes);
14645
14646       printf ("  0x%8.8lx ", addr);
14647
14648       for (j = 0; j < 16; j++)
14649         {
14650           if (j < lbytes)
14651             printf ("%2.2x", p[j]);
14652           else
14653             printf ("  ");
14654
14655           if ((j & 3) == 3)
14656             printf (" ");
14657         }
14658
14659       for (j = 0; j < lbytes; j++)
14660         {
14661           k = p[j];
14662           if (k >= ' ' && k < 0x7f)
14663             printf ("%c", k);
14664           else
14665             printf (".");
14666         }
14667
14668       putchar ('\n');
14669
14670       p  += lbytes;
14671       bytes -= lbytes;
14672       addr += lbytes;
14673     }
14674
14675   putchar ('\n');
14676 }
14677
14678 static unsigned char *
14679 display_msp430x_attribute (unsigned char * p,
14680                            const unsigned char * const end)
14681 {
14682   unsigned int len;
14683   unsigned int val;
14684   unsigned int tag;
14685
14686   tag = read_uleb128 (p, & len, end);
14687   p += len;
14688
14689   switch (tag)
14690     {
14691     case OFBA_MSPABI_Tag_ISA:
14692       val = read_uleb128 (p, &len, end);
14693       p += len;
14694       printf ("  Tag_ISA: ");
14695       switch (val)
14696         {
14697         case 0: printf (_("None\n")); break;
14698         case 1: printf (_("MSP430\n")); break;
14699         case 2: printf (_("MSP430X\n")); break;
14700         default: printf ("??? (%d)\n", val); break;
14701         }
14702       break;
14703
14704     case OFBA_MSPABI_Tag_Code_Model:
14705       val = read_uleb128 (p, &len, end);
14706       p += len;
14707       printf ("  Tag_Code_Model: ");
14708       switch (val)
14709         {
14710         case 0: printf (_("None\n")); break;
14711         case 1: printf (_("Small\n")); break;
14712         case 2: printf (_("Large\n")); break;
14713         default: printf ("??? (%d)\n", val); break;
14714         }
14715       break;
14716
14717     case OFBA_MSPABI_Tag_Data_Model:
14718       val = read_uleb128 (p, &len, end);
14719       p += len;
14720       printf ("  Tag_Data_Model: ");
14721       switch (val)
14722         {
14723         case 0: printf (_("None\n")); break;
14724         case 1: printf (_("Small\n")); break;
14725         case 2: printf (_("Large\n")); break;
14726         case 3: printf (_("Restricted Large\n")); break;
14727         default: printf ("??? (%d)\n", val); break;
14728         }
14729       break;
14730
14731     default:
14732       printf (_("  <unknown tag %d>: "), tag);
14733
14734       if (tag & 1)
14735         {
14736           putchar ('"');
14737           if (p < end - 1)
14738             {
14739               size_t maxlen = (end - p) - 1;
14740
14741               print_symbol ((int) maxlen, (const char *) p);
14742               p += strnlen ((char *) p, maxlen) + 1;
14743             }
14744           else
14745             {
14746               printf (_("<corrupt>"));
14747               p = (unsigned char *) end;
14748             }
14749           printf ("\"\n");
14750         }
14751       else
14752         {
14753           val = read_uleb128 (p, &len, end);
14754           p += len;
14755           printf ("%d (0x%x)\n", val, val);
14756         }
14757       break;
14758    }
14759
14760   assert (p <= end);
14761   return p;
14762 }
14763
14764 static bfd_boolean
14765 process_attributes (FILE * file,
14766                     const char * public_name,
14767                     unsigned int proc_type,
14768                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14769                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14770 {
14771   Elf_Internal_Shdr * sect;
14772   unsigned i;
14773   bfd_boolean res = TRUE;
14774
14775   /* Find the section header so that we get the size.  */
14776   for (i = 0, sect = section_headers;
14777        i < elf_header.e_shnum;
14778        i++, sect++)
14779     {
14780       unsigned char * contents;
14781       unsigned char * p;
14782
14783       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14784         continue;
14785
14786       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14787                                              sect->sh_size, _("attributes"));
14788       if (contents == NULL)
14789         {
14790           res = FALSE;
14791           continue;
14792         }
14793
14794       p = contents;
14795       /* The first character is the version of the attributes.
14796          Currently only version 1, (aka 'A') is recognised here.  */
14797       if (*p != 'A')
14798         {
14799           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14800           res = FALSE;
14801         }
14802       else
14803         {
14804           bfd_vma section_len;
14805
14806           section_len = sect->sh_size - 1;
14807           p++;
14808
14809           while (section_len > 0)
14810             {
14811               bfd_vma attr_len;
14812               unsigned int namelen;
14813               bfd_boolean public_section;
14814               bfd_boolean gnu_section;
14815
14816               if (section_len <= 4)
14817                 {
14818                   error (_("Tag section ends prematurely\n"));
14819                   res = FALSE;
14820                   break;
14821                 }
14822               attr_len = byte_get (p, 4);
14823               p += 4;
14824
14825               if (attr_len > section_len)
14826                 {
14827                   error (_("Bad attribute length (%u > %u)\n"),
14828                           (unsigned) attr_len, (unsigned) section_len);
14829                   attr_len = section_len;
14830                   res = FALSE;
14831                 }
14832               /* PR 17531: file: 001-101425-0.004  */
14833               else if (attr_len < 5)
14834                 {
14835                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14836                   res = FALSE;
14837                   break;
14838                 }
14839
14840               section_len -= attr_len;
14841               attr_len -= 4;
14842
14843               namelen = strnlen ((char *) p, attr_len) + 1;
14844               if (namelen == 0 || namelen >= attr_len)
14845                 {
14846                   error (_("Corrupt attribute section name\n"));
14847                   res = FALSE;
14848                   break;
14849                 }
14850
14851               printf (_("Attribute Section: "));
14852               print_symbol (INT_MAX, (const char *) p);
14853               putchar ('\n');
14854
14855               if (public_name && streq ((char *) p, public_name))
14856                 public_section = TRUE;
14857               else
14858                 public_section = FALSE;
14859
14860               if (streq ((char *) p, "gnu"))
14861                 gnu_section = TRUE;
14862               else
14863                 gnu_section = FALSE;
14864
14865               p += namelen;
14866               attr_len -= namelen;
14867
14868               while (attr_len > 0 && p < contents + sect->sh_size)
14869                 {
14870                   int tag;
14871                   int val;
14872                   bfd_vma size;
14873                   unsigned char * end;
14874
14875                   /* PR binutils/17531: Safe handling of corrupt files.  */
14876                   if (attr_len < 6)
14877                     {
14878                       error (_("Unused bytes at end of section\n"));
14879                       res = FALSE;
14880                       section_len = 0;
14881                       break;
14882                     }
14883
14884                   tag = *(p++);
14885                   size = byte_get (p, 4);
14886                   if (size > attr_len)
14887                     {
14888                       error (_("Bad subsection length (%u > %u)\n"),
14889                               (unsigned) size, (unsigned) attr_len);
14890                       res = FALSE;
14891                       size = attr_len;
14892                     }
14893                   /* PR binutils/17531: Safe handling of corrupt files.  */
14894                   if (size < 6)
14895                     {
14896                       error (_("Bad subsection length (%u < 6)\n"),
14897                               (unsigned) size);
14898                       res = FALSE;
14899                       section_len = 0;
14900                       break;
14901                     }
14902
14903                   attr_len -= size;
14904                   end = p + size - 1;
14905                   assert (end <= contents + sect->sh_size);
14906                   p += 4;
14907
14908                   switch (tag)
14909                     {
14910                     case 1:
14911                       printf (_("File Attributes\n"));
14912                       break;
14913                     case 2:
14914                       printf (_("Section Attributes:"));
14915                       goto do_numlist;
14916                     case 3:
14917                       printf (_("Symbol Attributes:"));
14918                       /* Fall through.  */
14919                     do_numlist:
14920                       for (;;)
14921                         {
14922                           unsigned int j;
14923
14924                           val = read_uleb128 (p, &j, end);
14925                           p += j;
14926                           if (val == 0)
14927                             break;
14928                           printf (" %d", val);
14929                         }
14930                       printf ("\n");
14931                       break;
14932                     default:
14933                       printf (_("Unknown tag: %d\n"), tag);
14934                       public_section = FALSE;
14935                       break;
14936                     }
14937
14938                   if (public_section && display_pub_attribute != NULL)
14939                     {
14940                       while (p < end)
14941                         p = display_pub_attribute (p, end);
14942                       assert (p == end);
14943                     }
14944                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14945                     {
14946                       while (p < end)
14947                         p = display_gnu_attribute (p,
14948                                                    display_proc_gnu_attribute,
14949                                                    end);
14950                       assert (p == end);
14951                     }
14952                   else if (p < end)
14953                     {
14954                       printf (_("  Unknown attribute:\n"));
14955                       display_raw_attribute (p, end);
14956                       p = end;
14957                     }
14958                   else
14959                     attr_len = 0;
14960                 }
14961             }
14962         }
14963
14964       free (contents);
14965     }
14966
14967   return res;
14968 }
14969
14970 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14971    Print the Address, Access and Initial fields of an entry at VMA ADDR
14972    and return the VMA of the next entry, or -1 if there was a problem.
14973    Does not read from DATA_END or beyond.  */
14974
14975 static bfd_vma
14976 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14977                       unsigned char * data_end)
14978 {
14979   printf ("  ");
14980   print_vma (addr, LONG_HEX);
14981   printf (" ");
14982   if (addr < pltgot + 0xfff0)
14983     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14984   else
14985     printf ("%10s", "");
14986   printf (" ");
14987   if (data == NULL)
14988     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14989   else
14990     {
14991       bfd_vma entry;
14992       unsigned char * from = data + addr - pltgot;
14993
14994       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14995         {
14996           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14997           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14998           return (bfd_vma) -1;
14999         }
15000       else
15001         {
15002           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15003           print_vma (entry, LONG_HEX);
15004         }
15005     }
15006   return addr + (is_32bit_elf ? 4 : 8);
15007 }
15008
15009 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15010    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15011    ADDR and return the VMA of the next entry.  */
15012
15013 static bfd_vma
15014 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15015 {
15016   printf ("  ");
15017   print_vma (addr, LONG_HEX);
15018   printf (" ");
15019   if (data == NULL)
15020     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15021   else
15022     {
15023       bfd_vma entry;
15024
15025       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15026       print_vma (entry, LONG_HEX);
15027     }
15028   return addr + (is_32bit_elf ? 4 : 8);
15029 }
15030
15031 static void
15032 print_mips_ases (unsigned int mask)
15033 {
15034   if (mask & AFL_ASE_DSP)
15035     fputs ("\n\tDSP ASE", stdout);
15036   if (mask & AFL_ASE_DSPR2)
15037     fputs ("\n\tDSP R2 ASE", stdout);
15038   if (mask & AFL_ASE_DSPR3)
15039     fputs ("\n\tDSP R3 ASE", stdout);
15040   if (mask & AFL_ASE_EVA)
15041     fputs ("\n\tEnhanced VA Scheme", stdout);
15042   if (mask & AFL_ASE_MCU)
15043     fputs ("\n\tMCU (MicroController) ASE", stdout);
15044   if (mask & AFL_ASE_MDMX)
15045     fputs ("\n\tMDMX ASE", stdout);
15046   if (mask & AFL_ASE_MIPS3D)
15047     fputs ("\n\tMIPS-3D ASE", stdout);
15048   if (mask & AFL_ASE_MT)
15049     fputs ("\n\tMT ASE", stdout);
15050   if (mask & AFL_ASE_SMARTMIPS)
15051     fputs ("\n\tSmartMIPS ASE", stdout);
15052   if (mask & AFL_ASE_VIRT)
15053     fputs ("\n\tVZ ASE", stdout);
15054   if (mask & AFL_ASE_MSA)
15055     fputs ("\n\tMSA ASE", stdout);
15056   if (mask & AFL_ASE_MIPS16)
15057     fputs ("\n\tMIPS16 ASE", stdout);
15058   if (mask & AFL_ASE_MICROMIPS)
15059     fputs ("\n\tMICROMIPS ASE", stdout);
15060   if (mask & AFL_ASE_XPA)
15061     fputs ("\n\tXPA ASE", stdout);
15062   if (mask & AFL_ASE_MIPS16E2)
15063     fputs ("\n\tMIPS16e2 ASE", stdout);
15064   if (mask == 0)
15065     fprintf (stdout, "\n\t%s", _("None"));
15066   else if ((mask & ~AFL_ASE_MASK) != 0)
15067     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15068 }
15069
15070 static void
15071 print_mips_isa_ext (unsigned int isa_ext)
15072 {
15073   switch (isa_ext)
15074     {
15075     case 0:
15076       fputs (_("None"), stdout);
15077       break;
15078     case AFL_EXT_XLR:
15079       fputs ("RMI XLR", stdout);
15080       break;
15081     case AFL_EXT_OCTEON3:
15082       fputs ("Cavium Networks Octeon3", stdout);
15083       break;
15084     case AFL_EXT_OCTEON2:
15085       fputs ("Cavium Networks Octeon2", stdout);
15086       break;
15087     case AFL_EXT_OCTEONP:
15088       fputs ("Cavium Networks OcteonP", stdout);
15089       break;
15090     case AFL_EXT_LOONGSON_3A:
15091       fputs ("Loongson 3A", stdout);
15092       break;
15093     case AFL_EXT_OCTEON:
15094       fputs ("Cavium Networks Octeon", stdout);
15095       break;
15096     case AFL_EXT_5900:
15097       fputs ("Toshiba R5900", stdout);
15098       break;
15099     case AFL_EXT_4650:
15100       fputs ("MIPS R4650", stdout);
15101       break;
15102     case AFL_EXT_4010:
15103       fputs ("LSI R4010", stdout);
15104       break;
15105     case AFL_EXT_4100:
15106       fputs ("NEC VR4100", stdout);
15107       break;
15108     case AFL_EXT_3900:
15109       fputs ("Toshiba R3900", stdout);
15110       break;
15111     case AFL_EXT_10000:
15112       fputs ("MIPS R10000", stdout);
15113       break;
15114     case AFL_EXT_SB1:
15115       fputs ("Broadcom SB-1", stdout);
15116       break;
15117     case AFL_EXT_4111:
15118       fputs ("NEC VR4111/VR4181", stdout);
15119       break;
15120     case AFL_EXT_4120:
15121       fputs ("NEC VR4120", stdout);
15122       break;
15123     case AFL_EXT_5400:
15124       fputs ("NEC VR5400", stdout);
15125       break;
15126     case AFL_EXT_5500:
15127       fputs ("NEC VR5500", stdout);
15128       break;
15129     case AFL_EXT_LOONGSON_2E:
15130       fputs ("ST Microelectronics Loongson 2E", stdout);
15131       break;
15132     case AFL_EXT_LOONGSON_2F:
15133       fputs ("ST Microelectronics Loongson 2F", stdout);
15134       break;
15135     case AFL_EXT_INTERAPTIV_MR2:
15136       fputs ("Imagination interAptiv MR2", stdout);
15137       break;
15138     default:
15139       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15140     }
15141 }
15142
15143 static signed int
15144 get_mips_reg_size (int reg_size)
15145 {
15146   return (reg_size == AFL_REG_NONE) ? 0
15147          : (reg_size == AFL_REG_32) ? 32
15148          : (reg_size == AFL_REG_64) ? 64
15149          : (reg_size == AFL_REG_128) ? 128
15150          : -1;
15151 }
15152
15153 static bfd_boolean
15154 process_mips_specific (FILE * file)
15155 {
15156   Elf_Internal_Dyn * entry;
15157   Elf_Internal_Shdr *sect = NULL;
15158   size_t liblist_offset = 0;
15159   size_t liblistno = 0;
15160   size_t conflictsno = 0;
15161   size_t options_offset = 0;
15162   size_t conflicts_offset = 0;
15163   size_t pltrelsz = 0;
15164   size_t pltrel = 0;
15165   bfd_vma pltgot = 0;
15166   bfd_vma mips_pltgot = 0;
15167   bfd_vma jmprel = 0;
15168   bfd_vma local_gotno = 0;
15169   bfd_vma gotsym = 0;
15170   bfd_vma symtabno = 0;
15171   bfd_boolean res = TRUE;
15172
15173   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15174                             display_mips_gnu_attribute))
15175     res = FALSE;
15176
15177   sect = find_section (".MIPS.abiflags");
15178
15179   if (sect != NULL)
15180     {
15181       Elf_External_ABIFlags_v0 *abiflags_ext;
15182       Elf_Internal_ABIFlags_v0 abiflags_in;
15183
15184       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15185         {
15186           error (_("Corrupt MIPS ABI Flags section.\n"));
15187           res = FALSE;
15188         }
15189       else
15190         {
15191           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15192                                    sect->sh_size, _("MIPS ABI Flags section"));
15193           if (abiflags_ext)
15194             {
15195               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15196               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15197               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15198               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15199               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15200               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15201               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15202               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15203               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15204               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15205               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15206
15207               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15208               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15209               if (abiflags_in.isa_rev > 1)
15210                 printf ("r%d", abiflags_in.isa_rev);
15211               printf ("\nGPR size: %d",
15212                       get_mips_reg_size (abiflags_in.gpr_size));
15213               printf ("\nCPR1 size: %d",
15214                       get_mips_reg_size (abiflags_in.cpr1_size));
15215               printf ("\nCPR2 size: %d",
15216                       get_mips_reg_size (abiflags_in.cpr2_size));
15217               fputs ("\nFP ABI: ", stdout);
15218               print_mips_fp_abi_value (abiflags_in.fp_abi);
15219               fputs ("ISA Extension: ", stdout);
15220               print_mips_isa_ext (abiflags_in.isa_ext);
15221               fputs ("\nASEs:", stdout);
15222               print_mips_ases (abiflags_in.ases);
15223               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15224               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15225               fputc ('\n', stdout);
15226               free (abiflags_ext);
15227             }
15228         }
15229     }
15230
15231   /* We have a lot of special sections.  Thanks SGI!  */
15232   if (dynamic_section == NULL)
15233     {
15234       /* No dynamic information available.  See if there is static GOT.  */
15235       sect = find_section (".got");
15236       if (sect != NULL)
15237         {
15238           unsigned char *data_end;
15239           unsigned char *data;
15240           bfd_vma ent, end;
15241           int addr_size;
15242
15243           pltgot = sect->sh_addr;
15244
15245           ent = pltgot;
15246           addr_size = (is_32bit_elf ? 4 : 8);
15247           end = pltgot + sect->sh_size;
15248
15249           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15250                                              end - pltgot, 1,
15251                                              _("Global Offset Table data"));
15252           /* PR 12855: Null data is handled gracefully throughout.  */
15253           data_end = data + (end - pltgot);
15254
15255           printf (_("\nStatic GOT:\n"));
15256           printf (_(" Canonical gp value: "));
15257           print_vma (ent + 0x7ff0, LONG_HEX);
15258           printf ("\n\n");
15259
15260           /* In a dynamic binary GOT[0] is reserved for the dynamic
15261              loader to store the lazy resolver pointer, however in
15262              a static binary it may well have been omitted and GOT
15263              reduced to a table of addresses.
15264              PR 21344: Check for the entry being fully available
15265              before fetching it.  */
15266           if (data
15267               && data + ent - pltgot + addr_size <= data_end
15268               && byte_get (data + ent - pltgot, addr_size) == 0)
15269             {
15270               printf (_(" Reserved entries:\n"));
15271               printf (_("  %*s %10s %*s\n"),
15272                       addr_size * 2, _("Address"), _("Access"),
15273                       addr_size * 2, _("Value"));
15274               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15275               printf ("\n");
15276               if (ent == (bfd_vma) -1)
15277                 goto sgot_print_fail;
15278
15279               /* Check for the MSB of GOT[1] being set, identifying a
15280                  GNU object.  This entry will be used by some runtime
15281                  loaders, to store the module pointer.  Otherwise this
15282                  is an ordinary local entry.
15283                  PR 21344: Check for the entry being fully available
15284                  before fetching it.  */
15285               if (data
15286                   && data + ent - pltgot + addr_size <= data_end
15287                   && (byte_get (data + ent - pltgot, addr_size)
15288                       >> (addr_size * 8 - 1)) != 0)
15289                 {
15290                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15291                   printf ("\n");
15292                   if (ent == (bfd_vma) -1)
15293                     goto sgot_print_fail;
15294                 }
15295               printf ("\n");
15296             }
15297
15298           if (ent < end)
15299             {
15300               printf (_(" Local entries:\n"));
15301               printf ("  %*s %10s %*s\n",
15302                       addr_size * 2, _("Address"), _("Access"),
15303                       addr_size * 2, _("Value"));
15304               while (ent < end)
15305                 {
15306                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15307                   printf ("\n");
15308                   if (ent == (bfd_vma) -1)
15309                     goto sgot_print_fail;
15310                 }
15311               printf ("\n");
15312             }
15313
15314         sgot_print_fail:
15315           if (data)
15316             free (data);
15317         }
15318       return res;
15319     }
15320
15321   for (entry = dynamic_section;
15322        /* PR 17531 file: 012-50589-0.004.  */
15323        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15324        ++entry)
15325     switch (entry->d_tag)
15326       {
15327       case DT_MIPS_LIBLIST:
15328         liblist_offset
15329           = offset_from_vma (file, entry->d_un.d_val,
15330                              liblistno * sizeof (Elf32_External_Lib));
15331         break;
15332       case DT_MIPS_LIBLISTNO:
15333         liblistno = entry->d_un.d_val;
15334         break;
15335       case DT_MIPS_OPTIONS:
15336         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15337         break;
15338       case DT_MIPS_CONFLICT:
15339         conflicts_offset
15340           = offset_from_vma (file, entry->d_un.d_val,
15341                              conflictsno * sizeof (Elf32_External_Conflict));
15342         break;
15343       case DT_MIPS_CONFLICTNO:
15344         conflictsno = entry->d_un.d_val;
15345         break;
15346       case DT_PLTGOT:
15347         pltgot = entry->d_un.d_ptr;
15348         break;
15349       case DT_MIPS_LOCAL_GOTNO:
15350         local_gotno = entry->d_un.d_val;
15351         break;
15352       case DT_MIPS_GOTSYM:
15353         gotsym = entry->d_un.d_val;
15354         break;
15355       case DT_MIPS_SYMTABNO:
15356         symtabno = entry->d_un.d_val;
15357         break;
15358       case DT_MIPS_PLTGOT:
15359         mips_pltgot = entry->d_un.d_ptr;
15360         break;
15361       case DT_PLTREL:
15362         pltrel = entry->d_un.d_val;
15363         break;
15364       case DT_PLTRELSZ:
15365         pltrelsz = entry->d_un.d_val;
15366         break;
15367       case DT_JMPREL:
15368         jmprel = entry->d_un.d_ptr;
15369         break;
15370       default:
15371         break;
15372       }
15373
15374   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15375     {
15376       Elf32_External_Lib * elib;
15377       size_t cnt;
15378
15379       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15380                                               liblistno,
15381                                               sizeof (Elf32_External_Lib),
15382                                               _("liblist section data"));
15383       if (elib)
15384         {
15385           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15386                   (unsigned long) liblistno);
15387           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15388                  stdout);
15389
15390           for (cnt = 0; cnt < liblistno; ++cnt)
15391             {
15392               Elf32_Lib liblist;
15393               time_t atime;
15394               char timebuf[128];
15395               struct tm * tmp;
15396
15397               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15398               atime = BYTE_GET (elib[cnt].l_time_stamp);
15399               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15400               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15401               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15402
15403               tmp = gmtime (&atime);
15404               snprintf (timebuf, sizeof (timebuf),
15405                         "%04u-%02u-%02uT%02u:%02u:%02u",
15406                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15407                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15408
15409               printf ("%3lu: ", (unsigned long) cnt);
15410               if (VALID_DYNAMIC_NAME (liblist.l_name))
15411                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15412               else
15413                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15414               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15415                       liblist.l_version);
15416
15417               if (liblist.l_flags == 0)
15418                 puts (_(" NONE"));
15419               else
15420                 {
15421                   static const struct
15422                   {
15423                     const char * name;
15424                     int bit;
15425                   }
15426                   l_flags_vals[] =
15427                   {
15428                     { " EXACT_MATCH", LL_EXACT_MATCH },
15429                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15430                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15431                     { " EXPORTS", LL_EXPORTS },
15432                     { " DELAY_LOAD", LL_DELAY_LOAD },
15433                     { " DELTA", LL_DELTA }
15434                   };
15435                   int flags = liblist.l_flags;
15436                   size_t fcnt;
15437
15438                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15439                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15440                       {
15441                         fputs (l_flags_vals[fcnt].name, stdout);
15442                         flags ^= l_flags_vals[fcnt].bit;
15443                       }
15444                   if (flags != 0)
15445                     printf (" %#x", (unsigned int) flags);
15446
15447                   puts ("");
15448                 }
15449             }
15450
15451           free (elib);
15452         }
15453       else
15454         res = FALSE;
15455     }
15456
15457   if (options_offset != 0)
15458     {
15459       Elf_External_Options * eopt;
15460       Elf_Internal_Options * iopt;
15461       Elf_Internal_Options * option;
15462       size_t offset;
15463       int cnt;
15464       sect = section_headers;
15465
15466       /* Find the section header so that we get the size.  */
15467       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15468       /* PR 17533 file: 012-277276-0.004.  */
15469       if (sect == NULL)
15470         {
15471           error (_("No MIPS_OPTIONS header found\n"));
15472           return FALSE;
15473         }
15474
15475       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15476                                                 sect->sh_size, _("options"));
15477       if (eopt)
15478         {
15479           iopt = (Elf_Internal_Options *)
15480               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15481           if (iopt == NULL)
15482             {
15483               error (_("Out of memory allocating space for MIPS options\n"));
15484               return FALSE;
15485             }
15486
15487           offset = cnt = 0;
15488           option = iopt;
15489
15490           while (offset <= sect->sh_size - sizeof (* eopt))
15491             {
15492               Elf_External_Options * eoption;
15493
15494               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15495
15496               option->kind = BYTE_GET (eoption->kind);
15497               option->size = BYTE_GET (eoption->size);
15498               option->section = BYTE_GET (eoption->section);
15499               option->info = BYTE_GET (eoption->info);
15500
15501               /* PR 17531: file: ffa0fa3b.  */
15502               if (option->size < sizeof (* eopt)
15503                   || offset + option->size > sect->sh_size)
15504                 {
15505                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15506                   return FALSE;
15507                 }
15508               offset += option->size;
15509
15510               ++option;
15511               ++cnt;
15512             }
15513
15514           printf (_("\nSection '%s' contains %d entries:\n"),
15515                   printable_section_name (sect), cnt);
15516
15517           option = iopt;
15518           offset = 0;
15519
15520           while (cnt-- > 0)
15521             {
15522               size_t len;
15523
15524               switch (option->kind)
15525                 {
15526                 case ODK_NULL:
15527                   /* This shouldn't happen.  */
15528                   printf (" NULL       %d %lx", option->section, option->info);
15529                   break;
15530                 case ODK_REGINFO:
15531                   printf (" REGINFO    ");
15532                   if (elf_header.e_machine == EM_MIPS)
15533                     {
15534                       /* 32bit form.  */
15535                       Elf32_External_RegInfo * ereg;
15536                       Elf32_RegInfo reginfo;
15537
15538                       ereg = (Elf32_External_RegInfo *) (option + 1);
15539                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15540                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15541                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15542                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15543                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15544                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15545
15546                       printf ("GPR %08lx  GP 0x%lx\n",
15547                               reginfo.ri_gprmask,
15548                               (unsigned long) reginfo.ri_gp_value);
15549                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15550                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15551                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15552                     }
15553                   else
15554                     {
15555                       /* 64 bit form.  */
15556                       Elf64_External_RegInfo * ereg;
15557                       Elf64_Internal_RegInfo reginfo;
15558
15559                       ereg = (Elf64_External_RegInfo *) (option + 1);
15560                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15561                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15562                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15563                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15564                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15565                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15566
15567                       printf ("GPR %08lx  GP 0x",
15568                               reginfo.ri_gprmask);
15569                       printf_vma (reginfo.ri_gp_value);
15570                       printf ("\n");
15571
15572                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15573                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15574                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15575                     }
15576                   ++option;
15577                   continue;
15578                 case ODK_EXCEPTIONS:
15579                   fputs (" EXCEPTIONS fpe_min(", stdout);
15580                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15581                   fputs (") fpe_max(", stdout);
15582                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15583                   fputs (")", stdout);
15584
15585                   if (option->info & OEX_PAGE0)
15586                     fputs (" PAGE0", stdout);
15587                   if (option->info & OEX_SMM)
15588                     fputs (" SMM", stdout);
15589                   if (option->info & OEX_FPDBUG)
15590                     fputs (" FPDBUG", stdout);
15591                   if (option->info & OEX_DISMISS)
15592                     fputs (" DISMISS", stdout);
15593                   break;
15594                 case ODK_PAD:
15595                   fputs (" PAD       ", stdout);
15596                   if (option->info & OPAD_PREFIX)
15597                     fputs (" PREFIX", stdout);
15598                   if (option->info & OPAD_POSTFIX)
15599                     fputs (" POSTFIX", stdout);
15600                   if (option->info & OPAD_SYMBOL)
15601                     fputs (" SYMBOL", stdout);
15602                   break;
15603                 case ODK_HWPATCH:
15604                   fputs (" HWPATCH   ", stdout);
15605                   if (option->info & OHW_R4KEOP)
15606                     fputs (" R4KEOP", stdout);
15607                   if (option->info & OHW_R8KPFETCH)
15608                     fputs (" R8KPFETCH", stdout);
15609                   if (option->info & OHW_R5KEOP)
15610                     fputs (" R5KEOP", stdout);
15611                   if (option->info & OHW_R5KCVTL)
15612                     fputs (" R5KCVTL", stdout);
15613                   break;
15614                 case ODK_FILL:
15615                   fputs (" FILL       ", stdout);
15616                   /* XXX Print content of info word?  */
15617                   break;
15618                 case ODK_TAGS:
15619                   fputs (" TAGS       ", stdout);
15620                   /* XXX Print content of info word?  */
15621                   break;
15622                 case ODK_HWAND:
15623                   fputs (" HWAND     ", stdout);
15624                   if (option->info & OHWA0_R4KEOP_CHECKED)
15625                     fputs (" R4KEOP_CHECKED", stdout);
15626                   if (option->info & OHWA0_R4KEOP_CLEAN)
15627                     fputs (" R4KEOP_CLEAN", stdout);
15628                   break;
15629                 case ODK_HWOR:
15630                   fputs (" HWOR      ", stdout);
15631                   if (option->info & OHWA0_R4KEOP_CHECKED)
15632                     fputs (" R4KEOP_CHECKED", stdout);
15633                   if (option->info & OHWA0_R4KEOP_CLEAN)
15634                     fputs (" R4KEOP_CLEAN", stdout);
15635                   break;
15636                 case ODK_GP_GROUP:
15637                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15638                           option->info & OGP_GROUP,
15639                           (option->info & OGP_SELF) >> 16);
15640                   break;
15641                 case ODK_IDENT:
15642                   printf (" IDENT     %#06lx  self-contained %#06lx",
15643                           option->info & OGP_GROUP,
15644                           (option->info & OGP_SELF) >> 16);
15645                   break;
15646                 default:
15647                   /* This shouldn't happen.  */
15648                   printf (" %3d ???     %d %lx",
15649                           option->kind, option->section, option->info);
15650                   break;
15651                 }
15652
15653               len = sizeof (* eopt);
15654               while (len < option->size)
15655                 {
15656                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15657
15658                   if (ISPRINT (datum))
15659                     printf ("%c", datum);
15660                   else
15661                     printf ("\\%03o", datum);
15662                   len ++;
15663                 }
15664               fputs ("\n", stdout);
15665
15666               offset += option->size;
15667               ++option;
15668             }
15669
15670           free (eopt);
15671         }
15672       else
15673         res = FALSE;
15674     }
15675
15676   if (conflicts_offset != 0 && conflictsno != 0)
15677     {
15678       Elf32_Conflict * iconf;
15679       size_t cnt;
15680
15681       if (dynamic_symbols == NULL)
15682         {
15683           error (_("conflict list found without a dynamic symbol table\n"));
15684           return FALSE;
15685         }
15686
15687       /* PR 21345 - print a slightly more helpful error message
15688          if we are sure that the cmalloc will fail.  */
15689       if (conflictsno * sizeof (* iconf) > current_file_size)
15690         {
15691           error (_("Overlarge number of conflicts detected: %lx\n"),
15692                  (long) conflictsno);
15693           return FALSE;
15694         }
15695
15696       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15697       if (iconf == NULL)
15698         {
15699           error (_("Out of memory allocating space for dynamic conflicts\n"));
15700           return FALSE;
15701         }
15702
15703       if (is_32bit_elf)
15704         {
15705           Elf32_External_Conflict * econf32;
15706
15707           econf32 = (Elf32_External_Conflict *)
15708               get_data (NULL, file, conflicts_offset, conflictsno,
15709                         sizeof (* econf32), _("conflict"));
15710           if (!econf32)
15711             return FALSE;
15712
15713           for (cnt = 0; cnt < conflictsno; ++cnt)
15714             iconf[cnt] = BYTE_GET (econf32[cnt]);
15715
15716           free (econf32);
15717         }
15718       else
15719         {
15720           Elf64_External_Conflict * econf64;
15721
15722           econf64 = (Elf64_External_Conflict *)
15723               get_data (NULL, file, conflicts_offset, conflictsno,
15724                         sizeof (* econf64), _("conflict"));
15725           if (!econf64)
15726             return FALSE;
15727
15728           for (cnt = 0; cnt < conflictsno; ++cnt)
15729             iconf[cnt] = BYTE_GET (econf64[cnt]);
15730
15731           free (econf64);
15732         }
15733
15734       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15735               (unsigned long) conflictsno);
15736       puts (_("  Num:    Index       Value  Name"));
15737
15738       for (cnt = 0; cnt < conflictsno; ++cnt)
15739         {
15740           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15741
15742           if (iconf[cnt] >= num_dynamic_syms)
15743             printf (_("<corrupt symbol index>"));
15744           else
15745             {
15746               Elf_Internal_Sym * psym;
15747
15748               psym = & dynamic_symbols[iconf[cnt]];
15749               print_vma (psym->st_value, FULL_HEX);
15750               putchar (' ');
15751               if (VALID_DYNAMIC_NAME (psym->st_name))
15752                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15753               else
15754                 printf (_("<corrupt: %14ld>"), psym->st_name);
15755             }
15756           putchar ('\n');
15757         }
15758
15759       free (iconf);
15760     }
15761
15762   if (pltgot != 0 && local_gotno != 0)
15763     {
15764       bfd_vma ent, local_end, global_end;
15765       size_t i, offset;
15766       unsigned char * data;
15767       unsigned char * data_end;
15768       int addr_size;
15769
15770       ent = pltgot;
15771       addr_size = (is_32bit_elf ? 4 : 8);
15772       local_end = pltgot + local_gotno * addr_size;
15773
15774       /* PR binutils/17533 file: 012-111227-0.004  */
15775       if (symtabno < gotsym)
15776         {
15777           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15778                  (unsigned long) gotsym, (unsigned long) symtabno);
15779           return FALSE;
15780         }
15781
15782       global_end = local_end + (symtabno - gotsym) * addr_size;
15783       /* PR 17531: file: 54c91a34.  */
15784       if (global_end < local_end)
15785         {
15786           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15787           return FALSE;
15788         }
15789
15790       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15791       data = (unsigned char *) get_data (NULL, file, offset,
15792                                          global_end - pltgot, 1,
15793                                          _("Global Offset Table data"));
15794       /* PR 12855: Null data is handled gracefully throughout.  */
15795       data_end = data + (global_end - pltgot);
15796
15797       printf (_("\nPrimary GOT:\n"));
15798       printf (_(" Canonical gp value: "));
15799       print_vma (pltgot + 0x7ff0, LONG_HEX);
15800       printf ("\n\n");
15801
15802       printf (_(" Reserved entries:\n"));
15803       printf (_("  %*s %10s %*s Purpose\n"),
15804               addr_size * 2, _("Address"), _("Access"),
15805               addr_size * 2, _("Initial"));
15806       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15807       printf (_(" Lazy resolver\n"));
15808       if (ent == (bfd_vma) -1)
15809         goto got_print_fail;
15810
15811       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15812          This entry will be used by some runtime loaders, to store the
15813          module pointer.  Otherwise this is an ordinary local entry.
15814          PR 21344: Check for the entry being fully available before
15815          fetching it.  */
15816       if (data
15817           && data + ent - pltgot + addr_size <= data_end
15818           && (byte_get (data + ent - pltgot, addr_size)
15819               >> (addr_size * 8 - 1)) != 0)
15820         {
15821           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15822           printf (_(" Module pointer (GNU extension)\n"));
15823           if (ent == (bfd_vma) -1)
15824             goto got_print_fail;
15825         }
15826       printf ("\n");
15827
15828       if (ent < local_end)
15829         {
15830           printf (_(" Local entries:\n"));
15831           printf ("  %*s %10s %*s\n",
15832                   addr_size * 2, _("Address"), _("Access"),
15833                   addr_size * 2, _("Initial"));
15834           while (ent < local_end)
15835             {
15836               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15837               printf ("\n");
15838               if (ent == (bfd_vma) -1)
15839                 goto got_print_fail;
15840             }
15841           printf ("\n");
15842         }
15843
15844       if (gotsym < symtabno)
15845         {
15846           int sym_width;
15847
15848           printf (_(" Global entries:\n"));
15849           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15850                   addr_size * 2, _("Address"),
15851                   _("Access"),
15852                   addr_size * 2, _("Initial"),
15853                   addr_size * 2, _("Sym.Val."),
15854                   _("Type"),
15855                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15856                   _("Ndx"), _("Name"));
15857
15858           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15859
15860           for (i = gotsym; i < symtabno; i++)
15861             {
15862               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15863               printf (" ");
15864
15865               if (dynamic_symbols == NULL)
15866                 printf (_("<no dynamic symbols>"));
15867               else if (i < num_dynamic_syms)
15868                 {
15869                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15870
15871                   print_vma (psym->st_value, LONG_HEX);
15872                   printf (" %-7s %3s ",
15873                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15874                           get_symbol_index_type (psym->st_shndx));
15875
15876                   if (VALID_DYNAMIC_NAME (psym->st_name))
15877                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15878                   else
15879                     printf (_("<corrupt: %14ld>"), psym->st_name);
15880                 }
15881               else
15882                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15883                         (unsigned long) i);
15884
15885               printf ("\n");
15886               if (ent == (bfd_vma) -1)
15887                 break;
15888             }
15889           printf ("\n");
15890         }
15891
15892     got_print_fail:
15893       if (data)
15894         free (data);
15895     }
15896
15897   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15898     {
15899       bfd_vma ent, end;
15900       size_t offset, rel_offset;
15901       unsigned long count, i;
15902       unsigned char * data;
15903       int addr_size, sym_width;
15904       Elf_Internal_Rela * rels;
15905
15906       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15907       if (pltrel == DT_RELA)
15908         {
15909           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15910             return FALSE;
15911         }
15912       else
15913         {
15914           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15915             return FALSE;
15916         }
15917
15918       ent = mips_pltgot;
15919       addr_size = (is_32bit_elf ? 4 : 8);
15920       end = mips_pltgot + (2 + count) * addr_size;
15921
15922       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15923       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15924                                          1, _("Procedure Linkage Table data"));
15925       if (data == NULL)
15926         return FALSE;
15927
15928       printf ("\nPLT GOT:\n\n");
15929       printf (_(" Reserved entries:\n"));
15930       printf (_("  %*s %*s Purpose\n"),
15931               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15932       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15933       printf (_(" PLT lazy resolver\n"));
15934       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15935       printf (_(" Module pointer\n"));
15936       printf ("\n");
15937
15938       printf (_(" Entries:\n"));
15939       printf ("  %*s %*s %*s %-7s %3s %s\n",
15940               addr_size * 2, _("Address"),
15941               addr_size * 2, _("Initial"),
15942               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15943       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15944       for (i = 0; i < count; i++)
15945         {
15946           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15947
15948           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15949           printf (" ");
15950
15951           if (idx >= num_dynamic_syms)
15952             printf (_("<corrupt symbol index: %lu>"), idx);
15953           else
15954             {
15955               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15956
15957               print_vma (psym->st_value, LONG_HEX);
15958               printf (" %-7s %3s ",
15959                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15960                       get_symbol_index_type (psym->st_shndx));
15961               if (VALID_DYNAMIC_NAME (psym->st_name))
15962                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15963               else
15964                 printf (_("<corrupt: %14ld>"), psym->st_name);
15965             }
15966           printf ("\n");
15967         }
15968       printf ("\n");
15969
15970       if (data)
15971         free (data);
15972       free (rels);
15973     }
15974
15975   return res;
15976 }
15977
15978 static bfd_boolean
15979 process_nds32_specific (FILE * file)
15980 {
15981   Elf_Internal_Shdr *sect = NULL;
15982
15983   sect = find_section (".nds32_e_flags");
15984   if (sect != NULL)
15985     {
15986       unsigned int *flag;
15987
15988       printf ("\nNDS32 elf flags section:\n");
15989       flag = get_data (NULL, file, sect->sh_offset, 1,
15990                        sect->sh_size, _("NDS32 elf flags section"));
15991
15992       if (! flag)
15993         return FALSE;
15994
15995       switch ((*flag) & 0x3)
15996         {
15997         case 0:
15998           printf ("(VEC_SIZE):\tNo entry.\n");
15999           break;
16000         case 1:
16001           printf ("(VEC_SIZE):\t4 bytes\n");
16002           break;
16003         case 2:
16004           printf ("(VEC_SIZE):\t16 bytes\n");
16005           break;
16006         case 3:
16007           printf ("(VEC_SIZE):\treserved\n");
16008           break;
16009         }
16010     }
16011
16012   return TRUE;
16013 }
16014
16015 static bfd_boolean
16016 process_gnu_liblist (FILE * file)
16017 {
16018   Elf_Internal_Shdr * section;
16019   Elf_Internal_Shdr * string_sec;
16020   Elf32_External_Lib * elib;
16021   char * strtab;
16022   size_t strtab_size;
16023   size_t cnt;
16024   unsigned i;
16025   bfd_boolean res = TRUE;
16026
16027   if (! do_arch)
16028     return TRUE;
16029
16030   for (i = 0, section = section_headers;
16031        i < elf_header.e_shnum;
16032        i++, section++)
16033     {
16034       switch (section->sh_type)
16035         {
16036         case SHT_GNU_LIBLIST:
16037           if (section->sh_link >= elf_header.e_shnum)
16038             break;
16039
16040           elib = (Elf32_External_Lib *)
16041               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16042                         _("liblist section data"));
16043
16044           if (elib == NULL)
16045             {
16046               res = FALSE;
16047               break;
16048             }
16049
16050           string_sec = section_headers + section->sh_link;
16051           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16052                                       string_sec->sh_size,
16053                                       _("liblist string table"));
16054           if (strtab == NULL
16055               || section->sh_entsize != sizeof (Elf32_External_Lib))
16056             {
16057               free (elib);
16058               free (strtab);
16059               res = FALSE;
16060               break;
16061             }
16062           strtab_size = string_sec->sh_size;
16063
16064           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16065                   printable_section_name (section),
16066                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16067
16068           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16069
16070           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16071                ++cnt)
16072             {
16073               Elf32_Lib liblist;
16074               time_t atime;
16075               char timebuf[128];
16076               struct tm * tmp;
16077
16078               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16079               atime = BYTE_GET (elib[cnt].l_time_stamp);
16080               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16081               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16082               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16083
16084               tmp = gmtime (&atime);
16085               snprintf (timebuf, sizeof (timebuf),
16086                         "%04u-%02u-%02uT%02u:%02u:%02u",
16087                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16088                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16089
16090               printf ("%3lu: ", (unsigned long) cnt);
16091               if (do_wide)
16092                 printf ("%-20s", liblist.l_name < strtab_size
16093                         ? strtab + liblist.l_name : _("<corrupt>"));
16094               else
16095                 printf ("%-20.20s", liblist.l_name < strtab_size
16096                         ? strtab + liblist.l_name : _("<corrupt>"));
16097               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16098                       liblist.l_version, liblist.l_flags);
16099             }
16100
16101           free (elib);
16102           free (strtab);
16103         }
16104     }
16105
16106   return res;
16107 }
16108
16109 static const char *
16110 get_note_type (unsigned e_type)
16111 {
16112   static char buff[64];
16113
16114   if (elf_header.e_type == ET_CORE)
16115     switch (e_type)
16116       {
16117       case NT_AUXV:
16118         return _("NT_AUXV (auxiliary vector)");
16119       case NT_PRSTATUS:
16120         return _("NT_PRSTATUS (prstatus structure)");
16121       case NT_FPREGSET:
16122         return _("NT_FPREGSET (floating point registers)");
16123       case NT_PRPSINFO:
16124         return _("NT_PRPSINFO (prpsinfo structure)");
16125       case NT_TASKSTRUCT:
16126         return _("NT_TASKSTRUCT (task structure)");
16127       case NT_PRXFPREG:
16128         return _("NT_PRXFPREG (user_xfpregs structure)");
16129       case NT_PPC_VMX:
16130         return _("NT_PPC_VMX (ppc Altivec registers)");
16131       case NT_PPC_VSX:
16132         return _("NT_PPC_VSX (ppc VSX registers)");
16133       case NT_386_TLS:
16134         return _("NT_386_TLS (x86 TLS information)");
16135       case NT_386_IOPERM:
16136         return _("NT_386_IOPERM (x86 I/O permissions)");
16137       case NT_X86_XSTATE:
16138         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16139       case NT_S390_HIGH_GPRS:
16140         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16141       case NT_S390_TIMER:
16142         return _("NT_S390_TIMER (s390 timer register)");
16143       case NT_S390_TODCMP:
16144         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16145       case NT_S390_TODPREG:
16146         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16147       case NT_S390_CTRS:
16148         return _("NT_S390_CTRS (s390 control registers)");
16149       case NT_S390_PREFIX:
16150         return _("NT_S390_PREFIX (s390 prefix register)");
16151       case NT_S390_LAST_BREAK:
16152         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16153       case NT_S390_SYSTEM_CALL:
16154         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16155       case NT_S390_TDB:
16156         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16157       case NT_S390_VXRS_LOW:
16158         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16159       case NT_S390_VXRS_HIGH:
16160         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16161       case NT_ARM_VFP:
16162         return _("NT_ARM_VFP (arm VFP registers)");
16163       case NT_ARM_TLS:
16164         return _("NT_ARM_TLS (AArch TLS registers)");
16165       case NT_ARM_HW_BREAK:
16166         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16167       case NT_ARM_HW_WATCH:
16168         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16169       case NT_PSTATUS:
16170         return _("NT_PSTATUS (pstatus structure)");
16171       case NT_FPREGS:
16172         return _("NT_FPREGS (floating point registers)");
16173       case NT_PSINFO:
16174         return _("NT_PSINFO (psinfo structure)");
16175       case NT_LWPSTATUS:
16176         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16177       case NT_LWPSINFO:
16178         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16179       case NT_WIN32PSTATUS:
16180         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16181       case NT_SIGINFO:
16182         return _("NT_SIGINFO (siginfo_t data)");
16183       case NT_FILE:
16184         return _("NT_FILE (mapped files)");
16185       default:
16186         break;
16187       }
16188   else
16189     switch (e_type)
16190       {
16191       case NT_VERSION:
16192         return _("NT_VERSION (version)");
16193       case NT_ARCH:
16194         return _("NT_ARCH (architecture)");
16195       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16196         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16197       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16198         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16199       default:
16200         break;
16201       }
16202
16203   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16204   return buff;
16205 }
16206
16207 static bfd_boolean
16208 print_core_note (Elf_Internal_Note *pnote)
16209 {
16210   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16211   bfd_vma count, page_size;
16212   unsigned char *descdata, *filenames, *descend;
16213
16214   if (pnote->type != NT_FILE)
16215     return TRUE;
16216
16217 #ifndef BFD64
16218   if (!is_32bit_elf)
16219     {
16220       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16221       /* Still "successful".  */
16222       return TRUE;
16223     }
16224 #endif
16225
16226   if (pnote->descsz < 2 * addr_size)
16227     {
16228       error (_("    Malformed note - too short for header\n"));
16229       return FALSE;
16230     }
16231
16232   descdata = (unsigned char *) pnote->descdata;
16233   descend = descdata + pnote->descsz;
16234
16235   if (descdata[pnote->descsz - 1] != '\0')
16236     {
16237       error (_("    Malformed note - does not end with \\0\n"));
16238       return FALSE;
16239     }
16240
16241   count = byte_get (descdata, addr_size);
16242   descdata += addr_size;
16243
16244   page_size = byte_get (descdata, addr_size);
16245   descdata += addr_size;
16246
16247   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16248     {
16249       error (_("    Malformed note - too short for supplied file count\n"));
16250       return FALSE;
16251     }
16252
16253   printf (_("    Page size: "));
16254   print_vma (page_size, DEC);
16255   printf ("\n");
16256
16257   printf (_("    %*s%*s%*s\n"),
16258           (int) (2 + 2 * addr_size), _("Start"),
16259           (int) (4 + 2 * addr_size), _("End"),
16260           (int) (4 + 2 * addr_size), _("Page Offset"));
16261   filenames = descdata + count * 3 * addr_size;
16262   while (count-- > 0)
16263     {
16264       bfd_vma start, end, file_ofs;
16265
16266       if (filenames == descend)
16267         {
16268           error (_("    Malformed note - filenames end too early\n"));
16269           return FALSE;
16270         }
16271
16272       start = byte_get (descdata, addr_size);
16273       descdata += addr_size;
16274       end = byte_get (descdata, addr_size);
16275       descdata += addr_size;
16276       file_ofs = byte_get (descdata, addr_size);
16277       descdata += addr_size;
16278
16279       printf ("    ");
16280       print_vma (start, FULL_HEX);
16281       printf ("  ");
16282       print_vma (end, FULL_HEX);
16283       printf ("  ");
16284       print_vma (file_ofs, FULL_HEX);
16285       printf ("\n        %s\n", filenames);
16286
16287       filenames += 1 + strlen ((char *) filenames);
16288     }
16289
16290   return TRUE;
16291 }
16292
16293 static const char *
16294 get_gnu_elf_note_type (unsigned e_type)
16295 {
16296   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16297   switch (e_type)
16298     {
16299     case NT_GNU_ABI_TAG:
16300       return _("NT_GNU_ABI_TAG (ABI version tag)");
16301     case NT_GNU_HWCAP:
16302       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16303     case NT_GNU_BUILD_ID:
16304       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16305     case NT_GNU_GOLD_VERSION:
16306       return _("NT_GNU_GOLD_VERSION (gold version)");
16307     case NT_GNU_PROPERTY_TYPE_0:
16308       return _("NT_GNU_PROPERTY_TYPE_0");
16309     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16310       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16311     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16312       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16313     default:
16314       {
16315         static char buff[64];
16316
16317         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16318         return buff;
16319       }
16320     }
16321 }
16322
16323 static void
16324 decode_x86_isa (unsigned int bitmask)
16325 {
16326   while (bitmask)
16327     {
16328       unsigned int bit = bitmask & (- bitmask);
16329
16330       bitmask &= ~ bit;
16331       switch (bit)
16332         {
16333         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16334         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16335         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16336         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16337         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16338         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16339         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16340         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16341         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16342         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16343         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16344         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16345         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16346         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16347         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16348         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16349         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16350         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16351         default: printf (_("<unknown: %x>"), bit); break;
16352         }
16353       if (bitmask)
16354         printf (", ");
16355     }
16356 }
16357
16358 static void
16359 decode_x86_feature (unsigned int type, unsigned int bitmask)
16360 {
16361   while (bitmask)
16362     {
16363       unsigned int bit = bitmask & (- bitmask);
16364
16365       bitmask &= ~ bit;
16366       switch (bit)
16367         {
16368         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16369           switch (type)
16370             {
16371             case GNU_PROPERTY_X86_FEATURE_1_AND:
16372               printf ("IBT");
16373               break;
16374             default:
16375               /* This should never happen.  */
16376               abort ();
16377             }
16378           break;
16379         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16380           switch (type)
16381             {
16382             case GNU_PROPERTY_X86_FEATURE_1_AND:
16383               printf ("SHSTK");
16384               break;
16385             default:
16386               /* This should never happen.  */
16387               abort ();
16388             }
16389           break;
16390         default:
16391           printf (_("<unknown: %x>"), bit);
16392           break;
16393         }
16394       if (bitmask)
16395         printf (", ");
16396     }
16397 }
16398
16399 static void
16400 print_gnu_property_note (Elf_Internal_Note * pnote)
16401 {
16402   unsigned char * ptr = (unsigned char *) pnote->descdata;
16403   unsigned char * ptr_end = ptr + pnote->descsz;
16404   unsigned int    size = is_32bit_elf ? 4 : 8;
16405
16406   printf (_("      Properties: "));
16407
16408   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16409     {
16410       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16411       return;
16412     }
16413
16414   while (1)
16415     {
16416       unsigned int j;
16417       unsigned int type = byte_get (ptr, 4);
16418       unsigned int datasz = byte_get (ptr + 4, 4);
16419
16420       ptr += 8;
16421
16422       if ((ptr + datasz) > ptr_end)
16423         {
16424           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16425                   type, datasz);
16426           break;
16427         }
16428
16429       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16430         {
16431           if (elf_header.e_machine == EM_X86_64
16432               || elf_header.e_machine == EM_IAMCU
16433               || elf_header.e_machine == EM_386)
16434             {
16435               switch (type)
16436                 {
16437                 case GNU_PROPERTY_X86_ISA_1_USED:
16438                   printf ("x86 ISA used: ");
16439                   if (datasz != 4)
16440                     printf (_("<corrupt length: %#x> "), datasz);
16441                   else
16442                     decode_x86_isa (byte_get (ptr, 4));
16443                   goto next;
16444
16445                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16446                   printf ("x86 ISA needed: ");
16447                   if (datasz != 4)
16448                     printf (_("<corrupt length: %#x> "), datasz);
16449                   else
16450                     decode_x86_isa (byte_get (ptr, 4));
16451                   goto next;
16452
16453                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16454                   printf ("x86 feature: ");
16455                   if (datasz != 4)
16456                     printf (_("<corrupt length: %#x> "), datasz);
16457                   else
16458                     decode_x86_feature (type, byte_get (ptr, 4));
16459                   goto next;
16460
16461                 default:
16462                   break;
16463                 }
16464             }
16465         }
16466       else
16467         {
16468           switch (type)
16469             {
16470             case GNU_PROPERTY_STACK_SIZE:
16471               printf (_("stack size: "));
16472               if (datasz != size)
16473                 printf (_("<corrupt length: %#x> "), datasz);
16474               else
16475                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16476               goto next;
16477
16478             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16479               printf ("no copy on protected ");
16480               if (datasz)
16481                 printf (_("<corrupt length: %#x> "), datasz);
16482               goto next;
16483
16484             default:
16485               break;
16486             }
16487         }
16488
16489       if (type < GNU_PROPERTY_LOPROC)
16490         printf (_("<unknown type %#x data: "), type);
16491       else if (type < GNU_PROPERTY_LOUSER)
16492         printf (_("<procesor-specific type %#x data: "), type);
16493       else
16494         printf (_("<application-specific type %#x data: "), type);
16495       for (j = 0; j < datasz; ++j)
16496         printf ("%02x ", ptr[j] & 0xff);
16497       printf (">");
16498
16499 next:
16500       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16501       if (ptr == ptr_end)
16502         break;
16503       else
16504         {
16505           if (do_wide)
16506             printf (", ");
16507           else
16508             printf ("\n\t");
16509         }
16510
16511       if (ptr > (ptr_end - 8))
16512         {
16513           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16514           break;
16515         }
16516     }
16517
16518   printf ("\n");
16519 }
16520
16521 static bfd_boolean
16522 print_gnu_note (Elf_Internal_Note *pnote)
16523 {
16524   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16525   switch (pnote->type)
16526     {
16527     case NT_GNU_BUILD_ID:
16528       {
16529         unsigned long i;
16530
16531         printf (_("    Build ID: "));
16532         for (i = 0; i < pnote->descsz; ++i)
16533           printf ("%02x", pnote->descdata[i] & 0xff);
16534         printf ("\n");
16535       }
16536       break;
16537
16538     case NT_GNU_ABI_TAG:
16539       {
16540         unsigned long os, major, minor, subminor;
16541         const char *osname;
16542
16543         /* PR 17531: file: 030-599401-0.004.  */
16544         if (pnote->descsz < 16)
16545           {
16546             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16547             break;
16548           }
16549
16550         os = byte_get ((unsigned char *) pnote->descdata, 4);
16551         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16552         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16553         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16554
16555         switch (os)
16556           {
16557           case GNU_ABI_TAG_LINUX:
16558             osname = "Linux";
16559             break;
16560           case GNU_ABI_TAG_HURD:
16561             osname = "Hurd";
16562             break;
16563           case GNU_ABI_TAG_SOLARIS:
16564             osname = "Solaris";
16565             break;
16566           case GNU_ABI_TAG_FREEBSD:
16567             osname = "FreeBSD";
16568             break;
16569           case GNU_ABI_TAG_NETBSD:
16570             osname = "NetBSD";
16571             break;
16572           case GNU_ABI_TAG_SYLLABLE:
16573             osname = "Syllable";
16574             break;
16575           case GNU_ABI_TAG_NACL:
16576             osname = "NaCl";
16577             break;
16578           default:
16579             osname = "Unknown";
16580             break;
16581           }
16582
16583         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16584                 major, minor, subminor);
16585       }
16586       break;
16587
16588     case NT_GNU_GOLD_VERSION:
16589       {
16590         unsigned long i;
16591
16592         printf (_("    Version: "));
16593         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16594           printf ("%c", pnote->descdata[i]);
16595         printf ("\n");
16596       }
16597       break;
16598
16599     case NT_GNU_HWCAP:
16600       {
16601         unsigned long num_entries, mask;
16602
16603         /* Hardware capabilities information.  Word 0 is the number of entries.
16604            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16605            is a series of entries, where each entry is a single byte followed
16606            by a nul terminated string.  The byte gives the bit number to test
16607            if enabled in the bitmask.  */
16608         printf (_("      Hardware Capabilities: "));
16609         if (pnote->descsz < 8)
16610           {
16611             error (_("<corrupt GNU_HWCAP>\n"));
16612             return FALSE;
16613           }
16614         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16615         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16616         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16617         /* FIXME: Add code to display the entries... */
16618       }
16619       break;
16620
16621     case NT_GNU_PROPERTY_TYPE_0:
16622       print_gnu_property_note (pnote);
16623       break;
16624
16625     default:
16626       /* Handle unrecognised types.  An error message should have already been
16627          created by get_gnu_elf_note_type(), so all that we need to do is to
16628          display the data.  */
16629       {
16630         unsigned long i;
16631
16632         printf (_("    Description data: "));
16633         for (i = 0; i < pnote->descsz; ++i)
16634           printf ("%02x ", pnote->descdata[i] & 0xff);
16635         printf ("\n");
16636       }
16637       break;
16638     }
16639
16640   return TRUE;
16641 }
16642
16643 static const char *
16644 get_v850_elf_note_type (enum v850_notes n_type)
16645 {
16646   static char buff[64];
16647
16648   switch (n_type)
16649     {
16650     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16651     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16652     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16653     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16654     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16655     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16656     default:
16657       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16658       return buff;
16659     }
16660 }
16661
16662 static bfd_boolean
16663 print_v850_note (Elf_Internal_Note * pnote)
16664 {
16665   unsigned int val;
16666
16667   if (pnote->descsz != 4)
16668     return FALSE;
16669
16670   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16671
16672   if (val == 0)
16673     {
16674       printf (_("not set\n"));
16675       return TRUE;
16676     }
16677
16678   switch (pnote->type)
16679     {
16680     case V850_NOTE_ALIGNMENT:
16681       switch (val)
16682         {
16683         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16684         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16685         }
16686       break;
16687
16688     case V850_NOTE_DATA_SIZE:
16689       switch (val)
16690         {
16691         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16692         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16693         }
16694       break;
16695
16696     case V850_NOTE_FPU_INFO:
16697       switch (val)
16698         {
16699         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16700         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16701         }
16702       break;
16703
16704     case V850_NOTE_MMU_INFO:
16705     case V850_NOTE_CACHE_INFO:
16706     case V850_NOTE_SIMD_INFO:
16707       if (val == EF_RH850_SIMD)
16708         {
16709           printf (_("yes\n"));
16710           return TRUE;
16711         }
16712       break;
16713
16714     default:
16715       /* An 'unknown note type' message will already have been displayed.  */
16716       break;
16717     }
16718
16719   printf (_("unknown value: %x\n"), val);
16720   return FALSE;
16721 }
16722
16723 static bfd_boolean
16724 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16725 {
16726   unsigned int version;
16727
16728   switch (pnote->type)
16729     {
16730     case NT_NETBSD_IDENT:
16731       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16732       if ((version / 10000) % 100)
16733         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16734                 version, version / 100000000, (version / 1000000) % 100,
16735                 (version / 10000) % 100 > 26 ? "Z" : "",
16736                 'A' + (version / 10000) % 26);
16737       else
16738         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16739                 version, version / 100000000, (version / 1000000) % 100,
16740                 (version / 100) % 100);
16741       return TRUE;
16742
16743     case NT_NETBSD_MARCH:
16744       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16745               pnote->descdata);
16746       return TRUE;
16747
16748     default:
16749       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16750               pnote->type);
16751       return FALSE;
16752     }
16753 }
16754
16755 static const char *
16756 get_freebsd_elfcore_note_type (unsigned e_type)
16757 {
16758   switch (e_type)
16759     {
16760     case NT_FREEBSD_THRMISC:
16761       return _("NT_THRMISC (thrmisc structure)");
16762     case NT_FREEBSD_PROCSTAT_PROC:
16763       return _("NT_PROCSTAT_PROC (proc data)");
16764     case NT_FREEBSD_PROCSTAT_FILES:
16765       return _("NT_PROCSTAT_FILES (files data)");
16766     case NT_FREEBSD_PROCSTAT_VMMAP:
16767       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16768     case NT_FREEBSD_PROCSTAT_GROUPS:
16769       return _("NT_PROCSTAT_GROUPS (groups data)");
16770     case NT_FREEBSD_PROCSTAT_UMASK:
16771       return _("NT_PROCSTAT_UMASK (umask data)");
16772     case NT_FREEBSD_PROCSTAT_RLIMIT:
16773       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16774     case NT_FREEBSD_PROCSTAT_OSREL:
16775       return _("NT_PROCSTAT_OSREL (osreldate data)");
16776     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16777       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16778     case NT_FREEBSD_PROCSTAT_AUXV:
16779       return _("NT_PROCSTAT_AUXV (auxv data)");
16780     }
16781   return get_note_type (e_type);
16782 }
16783
16784 static const char *
16785 get_netbsd_elfcore_note_type (unsigned e_type)
16786 {
16787   static char buff[64];
16788
16789   if (e_type == NT_NETBSDCORE_PROCINFO)
16790     {
16791       /* NetBSD core "procinfo" structure.  */
16792       return _("NetBSD procinfo structure");
16793     }
16794
16795   /* As of Jan 2002 there are no other machine-independent notes
16796      defined for NetBSD core files.  If the note type is less
16797      than the start of the machine-dependent note types, we don't
16798      understand it.  */
16799
16800   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16801     {
16802       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16803       return buff;
16804     }
16805
16806   switch (elf_header.e_machine)
16807     {
16808     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16809        and PT_GETFPREGS == mach+2.  */
16810
16811     case EM_OLD_ALPHA:
16812     case EM_ALPHA:
16813     case EM_SPARC:
16814     case EM_SPARC32PLUS:
16815     case EM_SPARCV9:
16816       switch (e_type)
16817         {
16818         case NT_NETBSDCORE_FIRSTMACH + 0:
16819           return _("PT_GETREGS (reg structure)");
16820         case NT_NETBSDCORE_FIRSTMACH + 2:
16821           return _("PT_GETFPREGS (fpreg structure)");
16822         default:
16823           break;
16824         }
16825       break;
16826
16827     /* On all other arch's, PT_GETREGS == mach+1 and
16828        PT_GETFPREGS == mach+3.  */
16829     default:
16830       switch (e_type)
16831         {
16832         case NT_NETBSDCORE_FIRSTMACH + 1:
16833           return _("PT_GETREGS (reg structure)");
16834         case NT_NETBSDCORE_FIRSTMACH + 3:
16835           return _("PT_GETFPREGS (fpreg structure)");
16836         default:
16837           break;
16838         }
16839     }
16840
16841   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16842             e_type - NT_NETBSDCORE_FIRSTMACH);
16843   return buff;
16844 }
16845
16846 static const char *
16847 get_stapsdt_note_type (unsigned e_type)
16848 {
16849   static char buff[64];
16850
16851   switch (e_type)
16852     {
16853     case NT_STAPSDT:
16854       return _("NT_STAPSDT (SystemTap probe descriptors)");
16855
16856     default:
16857       break;
16858     }
16859
16860   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16861   return buff;
16862 }
16863
16864 static bfd_boolean
16865 print_stapsdt_note (Elf_Internal_Note *pnote)
16866 {
16867   int addr_size = is_32bit_elf ? 4 : 8;
16868   char *data = pnote->descdata;
16869   char *data_end = pnote->descdata + pnote->descsz;
16870   bfd_vma pc, base_addr, semaphore;
16871   char *provider, *probe, *arg_fmt;
16872
16873   pc = byte_get ((unsigned char *) data, addr_size);
16874   data += addr_size;
16875   base_addr = byte_get ((unsigned char *) data, addr_size);
16876   data += addr_size;
16877   semaphore = byte_get ((unsigned char *) data, addr_size);
16878   data += addr_size;
16879
16880   provider = data;
16881   data += strlen (data) + 1;
16882   probe = data;
16883   data += strlen (data) + 1;
16884   arg_fmt = data;
16885   data += strlen (data) + 1;
16886
16887   printf (_("    Provider: %s\n"), provider);
16888   printf (_("    Name: %s\n"), probe);
16889   printf (_("    Location: "));
16890   print_vma (pc, FULL_HEX);
16891   printf (_(", Base: "));
16892   print_vma (base_addr, FULL_HEX);
16893   printf (_(", Semaphore: "));
16894   print_vma (semaphore, FULL_HEX);
16895   printf ("\n");
16896   printf (_("    Arguments: %s\n"), arg_fmt);
16897
16898   return data == data_end;
16899 }
16900
16901 static const char *
16902 get_ia64_vms_note_type (unsigned e_type)
16903 {
16904   static char buff[64];
16905
16906   switch (e_type)
16907     {
16908     case NT_VMS_MHD:
16909       return _("NT_VMS_MHD (module header)");
16910     case NT_VMS_LNM:
16911       return _("NT_VMS_LNM (language name)");
16912     case NT_VMS_SRC:
16913       return _("NT_VMS_SRC (source files)");
16914     case NT_VMS_TITLE:
16915       return "NT_VMS_TITLE";
16916     case NT_VMS_EIDC:
16917       return _("NT_VMS_EIDC (consistency check)");
16918     case NT_VMS_FPMODE:
16919       return _("NT_VMS_FPMODE (FP mode)");
16920     case NT_VMS_LINKTIME:
16921       return "NT_VMS_LINKTIME";
16922     case NT_VMS_IMGNAM:
16923       return _("NT_VMS_IMGNAM (image name)");
16924     case NT_VMS_IMGID:
16925       return _("NT_VMS_IMGID (image id)");
16926     case NT_VMS_LINKID:
16927       return _("NT_VMS_LINKID (link id)");
16928     case NT_VMS_IMGBID:
16929       return _("NT_VMS_IMGBID (build id)");
16930     case NT_VMS_GSTNAM:
16931       return _("NT_VMS_GSTNAM (sym table name)");
16932     case NT_VMS_ORIG_DYN:
16933       return "NT_VMS_ORIG_DYN";
16934     case NT_VMS_PATCHTIME:
16935       return "NT_VMS_PATCHTIME";
16936     default:
16937       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16938       return buff;
16939     }
16940 }
16941
16942 static bfd_boolean
16943 print_ia64_vms_note (Elf_Internal_Note * pnote)
16944 {
16945   switch (pnote->type)
16946     {
16947     case NT_VMS_MHD:
16948       if (pnote->descsz > 36)
16949         {
16950           size_t l = strlen (pnote->descdata + 34);
16951           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16952           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16953           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16954           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16955         }
16956       else
16957         printf (_("    Invalid size\n"));
16958       break;
16959     case NT_VMS_LNM:
16960       printf (_("   Language: %s\n"), pnote->descdata);
16961       break;
16962 #ifdef BFD64
16963     case NT_VMS_FPMODE:
16964       printf (_("   Floating Point mode: "));
16965       printf ("0x%016" BFD_VMA_FMT "x\n",
16966               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
16967       break;
16968     case NT_VMS_LINKTIME:
16969       printf (_("   Link time: "));
16970       print_vms_time
16971         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16972       printf ("\n");
16973       break;
16974     case NT_VMS_PATCHTIME:
16975       printf (_("   Patch time: "));
16976       print_vms_time
16977         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16978       printf ("\n");
16979       break;
16980     case NT_VMS_ORIG_DYN:
16981       printf (_("   Major id: %u,  minor id: %u\n"),
16982               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16983               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
16984       printf (_("   Last modified  : "));
16985       print_vms_time
16986         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
16987       printf (_("\n   Link flags  : "));
16988       printf ("0x%016" BFD_VMA_FMT "x\n",
16989               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
16990       printf (_("   Header flags: 0x%08x\n"),
16991               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
16992       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
16993       break;
16994 #endif
16995     case NT_VMS_IMGNAM:
16996       printf (_("    Image name: %s\n"), pnote->descdata);
16997       break;
16998     case NT_VMS_GSTNAM:
16999       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17000       break;
17001     case NT_VMS_IMGID:
17002       printf (_("    Image id: %s\n"), pnote->descdata);
17003       break;
17004     case NT_VMS_LINKID:
17005       printf (_("    Linker id: %s\n"), pnote->descdata);
17006       break;
17007     default:
17008       return FALSE;
17009     }
17010   return TRUE;
17011 }
17012
17013 /* Print the name of the symbol associated with a build attribute
17014    that is attached to address OFFSET.  */
17015
17016 static bfd_boolean
17017 print_symbol_for_build_attribute (FILE *         file,
17018                                   unsigned long  offset,
17019                                   bfd_boolean    is_open_attr)
17020 {
17021   static FILE *             saved_file = NULL;
17022   static char *             strtab;
17023   static unsigned long      strtablen;
17024   static Elf_Internal_Sym * symtab;
17025   static unsigned long      nsyms;
17026   Elf_Internal_Sym *        saved_sym = NULL;
17027   Elf_Internal_Sym *        sym;
17028
17029   if (section_headers != NULL
17030       && (saved_file == NULL || file != saved_file))
17031     {
17032       Elf_Internal_Shdr * symsec;
17033
17034       /* Load the symbol and string sections.  */
17035       for (symsec = section_headers;
17036            symsec < section_headers + elf_header.e_shnum;
17037            symsec ++)
17038         {
17039           if (symsec->sh_type == SHT_SYMTAB)
17040             {
17041               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17042
17043               if (symsec->sh_link < elf_header.e_shnum)
17044                 {
17045                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17046
17047                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17048                                               1, strtab_sec->sh_size,
17049                                               _("string table"));
17050                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17051                 }
17052             }
17053         }
17054       saved_file = file;
17055     }
17056
17057   if (symtab == NULL || strtab == NULL)
17058     {
17059       printf ("\n");
17060       return FALSE;
17061     }
17062
17063   /* Find a symbol whose value matches offset.  */
17064   for (sym = symtab; sym < symtab + nsyms; sym ++)
17065     if (sym->st_value == offset)
17066       {
17067         if (sym->st_name >= strtablen)
17068           /* Huh ?  This should not happen.  */
17069           continue;
17070
17071         if (strtab[sym->st_name] == 0)
17072           continue;
17073
17074         if (is_open_attr)
17075           {
17076             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17077                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17078                FUNC symbols entirely.  */
17079             switch (ELF_ST_TYPE (sym->st_info))
17080               {
17081               case STT_FILE:
17082                 saved_sym = sym;
17083                 /* We can stop searching now.  */
17084                 sym = symtab + nsyms;
17085                 continue;
17086
17087               case STT_OBJECT:
17088                 saved_sym = sym;
17089                 continue;
17090
17091               case STT_FUNC:
17092                 /* Ignore function symbols.  */
17093                 continue;
17094
17095               default:
17096                 break;
17097               }
17098
17099             switch (ELF_ST_BIND (sym->st_info))
17100               {
17101               case STB_GLOBAL:
17102                 if (saved_sym == NULL
17103                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17104                   saved_sym = sym;
17105                 break;
17106
17107               case STB_LOCAL:
17108                 if (saved_sym == NULL)
17109                   saved_sym = sym;
17110                 break;
17111
17112               default:
17113                 break;
17114               }
17115           }
17116         else
17117           {
17118             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17119               continue;
17120
17121             saved_sym = sym;
17122             break;
17123           }
17124       }
17125
17126   printf (" (%s: %s)\n",
17127           is_open_attr ? _("file") : _("func"),
17128           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17129   return TRUE;
17130 }
17131
17132 static bfd_boolean
17133 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17134                                        FILE *              file)
17135 {
17136   static unsigned long global_offset = 0;
17137   unsigned long        offset;
17138   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17139   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17140
17141   if (pnote->descsz == 0)
17142     {
17143       if (is_open_attr)
17144         {
17145           printf (_("    Applies from offset %#lx\n"), global_offset);
17146           return TRUE;
17147         }
17148       else
17149         {
17150           printf (_("    Applies to func at %#lx"), global_offset);
17151           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17152         }
17153     }
17154
17155   if (pnote->descsz != desc_size)
17156     {
17157       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17158       printf (_("    <invalid descsz>"));
17159       return FALSE;
17160     }
17161
17162   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17163
17164   if (is_open_attr)
17165     {
17166       printf (_("    Applies from offset %#lx"), offset);
17167       global_offset = offset;
17168     }
17169   else
17170     {
17171       printf (_("    Applies to func at %#lx"), offset);
17172     }
17173
17174   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17175 }
17176
17177 static bfd_boolean
17178 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17179 {
17180   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17181   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17182   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17183   char         name_type;
17184   char         name_attribute;
17185   const char * expected_types;
17186   const char * name = pnote->namedata;
17187   const char * text;
17188   int          left;
17189
17190   if (name == NULL || pnote->namesz < 2)
17191     {
17192       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17193       print_symbol (-20, _("  <corrupt name>"));
17194       return FALSE;
17195     }
17196
17197   switch ((name_type = * name))
17198     {
17199     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17200     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17201     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17202     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17203       printf ("%c", * name);
17204       break;
17205     default:
17206       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17207       print_symbol (-20, _("<unknown name type>"));
17208       return FALSE;
17209     }
17210
17211   left = 19;
17212   ++ name;
17213   text = NULL;
17214
17215   switch ((name_attribute = * name))
17216     {
17217     case GNU_BUILD_ATTRIBUTE_VERSION:
17218       text = _("<version>");
17219       expected_types = string_expected;
17220       ++ name;
17221       break;
17222     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17223       text = _("<stack prot>");
17224       expected_types = "!+*";
17225       ++ name;
17226       break;
17227     case GNU_BUILD_ATTRIBUTE_RELRO:
17228       text = _("<relro>");
17229       expected_types = bool_expected;
17230       ++ name;
17231       break;
17232     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17233       text = _("<stack size>");
17234       expected_types = number_expected;
17235       ++ name;
17236       break;
17237     case GNU_BUILD_ATTRIBUTE_TOOL:
17238       text = _("<tool>");
17239       expected_types = string_expected;
17240       ++ name;
17241       break;
17242     case GNU_BUILD_ATTRIBUTE_ABI:
17243       text = _("<ABI>");
17244       expected_types = "$*";
17245       ++ name;
17246       break;
17247     case GNU_BUILD_ATTRIBUTE_PIC:
17248       text = _("<PIC>");
17249       expected_types = number_expected;
17250       ++ name;
17251       break;
17252     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17253       text = _("<short enum>");
17254       expected_types = bool_expected;
17255       ++ name;
17256       break;
17257     default:
17258       if (ISPRINT (* name))
17259         {
17260           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17261
17262           if (len > left && ! do_wide)
17263             len = left;
17264           printf ("%.*s:", len, name);
17265           left -= len;
17266           name += len;
17267         }
17268       else
17269         {
17270           static char tmpbuf [128];
17271           error (_("unrecognised byte in name field: %d\n"), * name);
17272           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17273           text = tmpbuf;
17274           name ++;
17275         }
17276       expected_types = "*$!+";
17277       break;
17278     }
17279
17280   if (text)
17281     {
17282       printf ("%s", text);
17283       left -= strlen (text);
17284     }
17285
17286   if (strchr (expected_types, name_type) == NULL)
17287     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17288
17289   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17290     {
17291       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17292              (unsigned long) pnote->namesz,
17293              (long) (name - pnote->namedata));
17294       return FALSE;
17295     }
17296
17297   if (left < 1 && ! do_wide)
17298     return TRUE;
17299
17300   switch (name_type)
17301     {
17302     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17303       {
17304         unsigned int        bytes;
17305         unsigned long long  val = 0;
17306         unsigned int        shift = 0;
17307         char *              decoded = NULL;
17308
17309         bytes = pnote->namesz - (name - pnote->namedata);
17310         if (bytes > 0)
17311           /* The -1 is because the name field is always 0 terminated, and we
17312              want to be able to ensure that the shift in the while loop below
17313              will not overflow.  */
17314           -- bytes;
17315
17316         if (bytes > sizeof (val))
17317           {
17318             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17319                      pnote->namesz, name, pnote->namedata);
17320             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17321                    bytes);
17322             bytes = sizeof (val);
17323           }
17324         /* We do not bother to warn if bytes == 0 as this can
17325            happen with some early versions of the gcc plugin.  */
17326
17327         while (bytes --)
17328           {
17329             unsigned long byte = (* name ++) & 0xff;
17330
17331             val |= byte << shift;
17332             shift += 8;
17333           }
17334
17335         switch (name_attribute)
17336           {
17337           case GNU_BUILD_ATTRIBUTE_PIC:
17338             switch (val)
17339               {
17340               case 0: decoded = "static"; break;
17341               case 1: decoded = "pic"; break;
17342               case 2: decoded = "PIC"; break;
17343               case 3: decoded = "pie"; break;
17344               case 4: decoded = "PIE"; break;
17345               default: break;
17346               }
17347             break;
17348           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17349             switch (val)
17350               {
17351                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17352               case 0: decoded = "off"; break;
17353               case 1: decoded = "on"; break;
17354               case 2: decoded = "all"; break;
17355               case 3: decoded = "strong"; break;
17356               case 4: decoded = "explicit"; break;
17357               default: break;
17358               }
17359             break;
17360           default:
17361             break;
17362           }
17363
17364         if (decoded != NULL)
17365           {
17366             print_symbol (-left, decoded);
17367             left = 0;
17368           }
17369         else if (val == 0)
17370           {
17371             printf ("0x0");
17372             left -= 3;
17373           }
17374         else
17375           {
17376             if (do_wide)
17377               left -= printf ("0x%llx", val);
17378             else
17379               left -= printf ("0x%-.*llx", left, val);
17380           }
17381       }
17382       break;
17383     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17384       left -= print_symbol (- left, name);
17385       break;
17386     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17387       left -= print_symbol (- left, "true");
17388       break;
17389     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17390       left -= print_symbol (- left, "false");
17391       break;
17392     }
17393
17394   if (do_wide && left > 0)
17395     printf ("%-*s", left, " ");
17396
17397   return TRUE;
17398 }
17399
17400 /* Note that by the ELF standard, the name field is already null byte
17401    terminated, and namesz includes the terminating null byte.
17402    I.E. the value of namesz for the name "FSF" is 4.
17403
17404    If the value of namesz is zero, there is no name present.  */
17405
17406 static bfd_boolean
17407 process_note (Elf_Internal_Note *  pnote,
17408               FILE *               file)
17409 {
17410   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17411   const char * nt;
17412
17413   if (pnote->namesz == 0)
17414     /* If there is no note name, then use the default set of
17415        note type strings.  */
17416     nt = get_note_type (pnote->type);
17417
17418   else if (const_strneq (pnote->namedata, "GNU"))
17419     /* GNU-specific object file notes.  */
17420     nt = get_gnu_elf_note_type (pnote->type);
17421
17422   else if (const_strneq (pnote->namedata, "FreeBSD"))
17423     /* FreeBSD-specific core file notes.  */
17424     nt = get_freebsd_elfcore_note_type (pnote->type);
17425
17426   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17427     /* NetBSD-specific core file notes.  */
17428     nt = get_netbsd_elfcore_note_type (pnote->type);
17429
17430   else if (const_strneq (pnote->namedata, "NetBSD"))
17431     /* NetBSD-specific core file notes.  */
17432     return process_netbsd_elf_note (pnote);
17433
17434   else if (strneq (pnote->namedata, "SPU/", 4))
17435     {
17436       /* SPU-specific core file notes.  */
17437       nt = pnote->namedata + 4;
17438       name = "SPU";
17439     }
17440
17441   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17442     /* VMS/ia64-specific file notes.  */
17443     nt = get_ia64_vms_note_type (pnote->type);
17444
17445   else if (const_strneq (pnote->namedata, "stapsdt"))
17446     nt = get_stapsdt_note_type (pnote->type);
17447
17448   else
17449     /* Don't recognize this note name; just use the default set of
17450        note type strings.  */
17451     nt = get_note_type (pnote->type);
17452
17453   printf ("  ");
17454
17455   if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17456       || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17457     print_gnu_build_attribute_name (pnote);
17458   else
17459     print_symbol (-20, name);
17460
17461   if (do_wide)
17462     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17463   else
17464     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17465
17466   if (const_strneq (pnote->namedata, "IPF/VMS"))
17467     return print_ia64_vms_note (pnote);
17468   else if (const_strneq (pnote->namedata, "GNU"))
17469     return print_gnu_note (pnote);
17470   else if (const_strneq (pnote->namedata, "stapsdt"))
17471     return print_stapsdt_note (pnote);
17472   else if (const_strneq (pnote->namedata, "CORE"))
17473     return print_core_note (pnote);
17474   else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17475            || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17476     return print_gnu_build_attribute_description (pnote, file);
17477
17478   if (pnote->descsz)
17479     {
17480       unsigned long i;
17481
17482       printf (_("   description data: "));
17483       for (i = 0; i < pnote->descsz; i++)
17484         printf ("%02x ", pnote->descdata[i]);
17485     }
17486
17487   if (do_wide)
17488     printf ("\n");
17489
17490   return TRUE;
17491 }
17492
17493 static bfd_boolean
17494 process_notes_at (FILE *              file,
17495                   Elf_Internal_Shdr * section,
17496                   bfd_vma             offset,
17497                   bfd_vma             length)
17498 {
17499   Elf_External_Note * pnotes;
17500   Elf_External_Note * external;
17501   char * end;
17502   bfd_boolean res = TRUE;
17503
17504   if (length <= 0)
17505     return FALSE;
17506
17507   if (section)
17508     {
17509       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17510       if (pnotes)
17511         {
17512           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17513             return FALSE;
17514         }
17515     }
17516   else
17517     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17518                                              _("notes"));
17519   if (pnotes == NULL)
17520     return FALSE;
17521
17522   external = pnotes;
17523
17524   if (section)
17525     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17526   else
17527     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17528             (unsigned long) offset, (unsigned long) length);
17529
17530   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17531
17532   end = (char *) pnotes + length;
17533   while ((char *) external < end)
17534     {
17535       Elf_Internal_Note inote;
17536       size_t min_notesz;
17537       char *next;
17538       char * temp = NULL;
17539       size_t data_remaining = end - (char *) external;
17540
17541       if (!is_ia64_vms ())
17542         {
17543           /* PR binutils/15191
17544              Make sure that there is enough data to read.  */
17545           min_notesz = offsetof (Elf_External_Note, name);
17546           if (data_remaining < min_notesz)
17547             {
17548               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17549                     (int) data_remaining);
17550               break;
17551             }
17552           inote.type     = BYTE_GET (external->type);
17553           inote.namesz   = BYTE_GET (external->namesz);
17554           inote.namedata = external->name;
17555           inote.descsz   = BYTE_GET (external->descsz);
17556           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17557           /* PR 17531: file: 3443835e.  */
17558           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17559             {
17560               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17561                     inote.namesz, (long)(end - inote.namedata));
17562               inote.descdata = inote.namedata;
17563               inote.namesz   = 0;
17564             }
17565
17566           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17567           next = inote.descdata + align_power (inote.descsz, 2);
17568         }
17569       else
17570         {
17571           Elf64_External_VMS_Note *vms_external;
17572
17573           /* PR binutils/15191
17574              Make sure that there is enough data to read.  */
17575           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17576           if (data_remaining < min_notesz)
17577             {
17578               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17579                     (int) data_remaining);
17580               break;
17581             }
17582
17583           vms_external = (Elf64_External_VMS_Note *) external;
17584           inote.type     = BYTE_GET (vms_external->type);
17585           inote.namesz   = BYTE_GET (vms_external->namesz);
17586           inote.namedata = vms_external->name;
17587           inote.descsz   = BYTE_GET (vms_external->descsz);
17588           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17589           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17590           next = inote.descdata + align_power (inote.descsz, 3);
17591         }
17592
17593       if (inote.descdata < (char *) external + min_notesz
17594           || next < (char *) external + min_notesz
17595           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17596           || inote.namedata + inote.namesz < inote.namedata
17597           || inote.descdata + inote.descsz < inote.descdata
17598           || data_remaining < (size_t)(next - (char *) external))
17599         {
17600           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17601                 (unsigned long) ((char *) external - (char *) pnotes));
17602           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17603                 inote.type, inote.namesz, inote.descsz);
17604           break;
17605         }
17606
17607       external = (Elf_External_Note *) next;
17608
17609       /* Verify that name is null terminated.  It appears that at least
17610          one version of Linux (RedHat 6.0) generates corefiles that don't
17611          comply with the ELF spec by failing to include the null byte in
17612          namesz.  */
17613       if (inote.namedata[inote.namesz - 1] != '\0')
17614         {
17615           temp = (char *) malloc (inote.namesz + 1);
17616           if (temp == NULL)
17617             {
17618               error (_("Out of memory allocating space for inote name\n"));
17619               res = FALSE;
17620               break;
17621             }
17622
17623           memcpy (temp, inote.namedata, inote.namesz);
17624           temp[inote.namesz] = 0;
17625
17626           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17627           inote.namedata = temp;
17628         }
17629
17630       if (! process_note (& inote, file))
17631         res = FALSE;
17632
17633       if (temp != NULL)
17634         {
17635           free (temp);
17636           temp = NULL;
17637         }
17638     }
17639
17640   free (pnotes);
17641
17642   return res;
17643 }
17644
17645 static bfd_boolean
17646 process_corefile_note_segments (FILE * file)
17647 {
17648   Elf_Internal_Phdr * segment;
17649   unsigned int i;
17650   bfd_boolean res = TRUE;
17651
17652   if (! get_program_headers (file))
17653     return TRUE;
17654
17655   for (i = 0, segment = program_headers;
17656        i < elf_header.e_phnum;
17657        i++, segment++)
17658     {
17659       if (segment->p_type == PT_NOTE)
17660         if (! process_notes_at (file, NULL,
17661                                 (bfd_vma) segment->p_offset,
17662                                 (bfd_vma) segment->p_filesz))
17663           res = FALSE;
17664     }
17665
17666   return res;
17667 }
17668
17669 static bfd_boolean
17670 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17671 {
17672   Elf_External_Note * pnotes;
17673   Elf_External_Note * external;
17674   char * end;
17675   bfd_boolean res = TRUE;
17676
17677   if (length <= 0)
17678     return FALSE;
17679
17680   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17681                                            _("v850 notes"));
17682   if (pnotes == NULL)
17683     return FALSE;
17684
17685   external = pnotes;
17686   end = (char*) pnotes + length;
17687
17688   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17689           (unsigned long) offset, (unsigned long) length);
17690
17691   while ((char *) external + sizeof (Elf_External_Note) < end)
17692     {
17693       Elf_External_Note * next;
17694       Elf_Internal_Note inote;
17695
17696       inote.type     = BYTE_GET (external->type);
17697       inote.namesz   = BYTE_GET (external->namesz);
17698       inote.namedata = external->name;
17699       inote.descsz   = BYTE_GET (external->descsz);
17700       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17701       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17702
17703       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17704         {
17705           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17706           inote.descdata = inote.namedata;
17707           inote.namesz   = 0;
17708         }
17709
17710       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17711
17712       if (   ((char *) next > end)
17713           || ((char *) next <  (char *) pnotes))
17714         {
17715           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17716                 (unsigned long) ((char *) external - (char *) pnotes));
17717           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17718                 inote.type, inote.namesz, inote.descsz);
17719           break;
17720         }
17721
17722       external = next;
17723
17724       /* Prevent out-of-bounds indexing.  */
17725       if (   inote.namedata + inote.namesz > end
17726           || inote.namedata + inote.namesz < inote.namedata)
17727         {
17728           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17729                 (unsigned long) ((char *) external - (char *) pnotes));
17730           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17731                 inote.type, inote.namesz, inote.descsz);
17732           break;
17733         }
17734
17735       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17736
17737       if (! print_v850_note (& inote))
17738         {
17739           res = FALSE;
17740           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17741                   inote.namesz, inote.descsz);
17742         }
17743     }
17744
17745   free (pnotes);
17746
17747   return res;
17748 }
17749
17750 static bfd_boolean
17751 process_note_sections (FILE * file)
17752 {
17753   Elf_Internal_Shdr * section;
17754   unsigned long i;
17755   unsigned int n = 0;
17756   bfd_boolean res = TRUE;
17757
17758   for (i = 0, section = section_headers;
17759        i < elf_header.e_shnum && section != NULL;
17760        i++, section++)
17761     {
17762       if (section->sh_type == SHT_NOTE)
17763         {
17764           if (! process_notes_at (file, section,
17765                                   (bfd_vma) section->sh_offset,
17766                                   (bfd_vma) section->sh_size))
17767             res = FALSE;
17768           n++;
17769         }
17770
17771       if ((   elf_header.e_machine == EM_V800
17772            || elf_header.e_machine == EM_V850
17773            || elf_header.e_machine == EM_CYGNUS_V850)
17774           && section->sh_type == SHT_RENESAS_INFO)
17775         {
17776           if (! process_v850_notes (file,
17777                                     (bfd_vma) section->sh_offset,
17778                                     (bfd_vma) section->sh_size))
17779             res = FALSE;
17780           n++;
17781         }
17782     }
17783
17784   if (n == 0)
17785     /* Try processing NOTE segments instead.  */
17786     return process_corefile_note_segments (file);
17787
17788   return res;
17789 }
17790
17791 static bfd_boolean
17792 process_notes (FILE * file)
17793 {
17794   /* If we have not been asked to display the notes then do nothing.  */
17795   if (! do_notes)
17796     return TRUE;
17797
17798   if (elf_header.e_type != ET_CORE)
17799     return process_note_sections (file);
17800
17801   /* No program headers means no NOTE segment.  */
17802   if (elf_header.e_phnum > 0)
17803     return process_corefile_note_segments (file);
17804
17805   printf (_("No note segments present in the core file.\n"));
17806   return TRUE;
17807 }
17808
17809 static unsigned char *
17810 display_public_gnu_attributes (unsigned char * start,
17811                                const unsigned char * const end)
17812 {
17813   printf (_("  Unknown GNU attribute: %s\n"), start);
17814
17815   start += strnlen ((char *) start, end - start);
17816   display_raw_attribute (start, end);
17817
17818   return (unsigned char *) end;
17819 }
17820
17821 static unsigned char *
17822 display_generic_attribute (unsigned char * start,
17823                            unsigned int tag,
17824                            const unsigned char * const end)
17825 {
17826   if (tag == 0)
17827     return (unsigned char *) end;
17828
17829   return display_tag_value (tag, start, end);
17830 }
17831
17832 static bfd_boolean
17833 process_arch_specific (FILE * file)
17834 {
17835   if (! do_arch)
17836     return TRUE;
17837
17838   switch (elf_header.e_machine)
17839     {
17840     case EM_ARC:
17841     case EM_ARC_COMPACT:
17842     case EM_ARC_COMPACT2:
17843       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17844                                  display_arc_attribute,
17845                                  display_generic_attribute);
17846     case EM_ARM:
17847       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17848                                  display_arm_attribute,
17849                                  display_generic_attribute);
17850
17851     case EM_MIPS:
17852     case EM_MIPS_RS3_LE:
17853       return process_mips_specific (file);
17854
17855     case EM_MSP430:
17856      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17857                                  display_msp430x_attribute,
17858                                  display_generic_attribute);
17859
17860     case EM_NDS32:
17861       return process_nds32_specific (file);
17862
17863     case EM_PPC:
17864     case EM_PPC64:
17865       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17866                                  display_power_gnu_attribute);
17867
17868     case EM_S390:
17869     case EM_S390_OLD:
17870       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17871                                  display_s390_gnu_attribute);
17872
17873     case EM_SPARC:
17874     case EM_SPARC32PLUS:
17875     case EM_SPARCV9:
17876       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17877                                  display_sparc_gnu_attribute);
17878
17879     case EM_TI_C6000:
17880       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17881                                  display_tic6x_attribute,
17882                                  display_generic_attribute);
17883
17884     default:
17885       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17886                                  display_public_gnu_attributes,
17887                                  display_generic_attribute);
17888     }
17889 }
17890
17891 static bfd_boolean
17892 get_file_header (FILE * file)
17893 {
17894   /* Read in the identity array.  */
17895   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17896     return FALSE;
17897
17898   /* Determine how to read the rest of the header.  */
17899   switch (elf_header.e_ident[EI_DATA])
17900     {
17901     default:
17902     case ELFDATANONE:
17903     case ELFDATA2LSB:
17904       byte_get = byte_get_little_endian;
17905       byte_put = byte_put_little_endian;
17906       break;
17907     case ELFDATA2MSB:
17908       byte_get = byte_get_big_endian;
17909       byte_put = byte_put_big_endian;
17910       break;
17911     }
17912
17913   /* For now we only support 32 bit and 64 bit ELF files.  */
17914   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17915
17916   /* Read in the rest of the header.  */
17917   if (is_32bit_elf)
17918     {
17919       Elf32_External_Ehdr ehdr32;
17920
17921       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17922         return FALSE;
17923
17924       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17925       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17926       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17927       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17928       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17929       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17930       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17931       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17932       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17933       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17934       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17935       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17936       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17937     }
17938   else
17939     {
17940       Elf64_External_Ehdr ehdr64;
17941
17942       /* If we have been compiled with sizeof (bfd_vma) == 4, then
17943          we will not be able to cope with the 64bit data found in
17944          64 ELF files.  Detect this now and abort before we start
17945          overwriting things.  */
17946       if (sizeof (bfd_vma) < 8)
17947         {
17948           error (_("This instance of readelf has been built without support for a\n\
17949 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17950           return FALSE;
17951         }
17952
17953       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
17954         return FALSE;
17955
17956       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
17957       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
17958       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
17959       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
17960       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
17961       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
17962       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
17963       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
17964       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17965       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
17966       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17967       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
17968       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
17969     }
17970
17971   if (elf_header.e_shoff)
17972     {
17973       /* There may be some extensions in the first section header.  Don't
17974          bomb if we can't read it.  */
17975       if (is_32bit_elf)
17976         get_32bit_section_headers (file, TRUE);
17977       else
17978         get_64bit_section_headers (file, TRUE);
17979     }
17980
17981   return TRUE;
17982 }
17983
17984 /* Process one ELF object file according to the command line options.
17985    This file may actually be stored in an archive.  The file is
17986    positioned at the start of the ELF object.  Returns TRUE if no
17987    problems were encountered, FALSE otherwise.  */
17988
17989 static bfd_boolean
17990 process_object (char * file_name, FILE * file)
17991 {
17992   unsigned int i;
17993   bfd_boolean res = TRUE;
17994
17995   if (! get_file_header (file))
17996     {
17997       error (_("%s: Failed to read file header\n"), file_name);
17998       return FALSE;
17999     }
18000
18001   /* Initialise per file variables.  */
18002   for (i = ARRAY_SIZE (version_info); i--;)
18003     version_info[i] = 0;
18004
18005   for (i = ARRAY_SIZE (dynamic_info); i--;)
18006     dynamic_info[i] = 0;
18007   dynamic_info_DT_GNU_HASH = 0;
18008
18009   /* Process the file.  */
18010   if (show_name)
18011     printf (_("\nFile: %s\n"), file_name);
18012
18013   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18014      Note we do this even if cmdline_dump_sects is empty because we
18015      must make sure that the dump_sets array is zeroed out before each
18016      object file is processed.  */
18017   if (num_dump_sects > num_cmdline_dump_sects)
18018     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18019
18020   if (num_cmdline_dump_sects > 0)
18021     {
18022       if (num_dump_sects == 0)
18023         /* A sneaky way of allocating the dump_sects array.  */
18024         request_dump_bynumber (num_cmdline_dump_sects, 0);
18025
18026       assert (num_dump_sects >= num_cmdline_dump_sects);
18027       memcpy (dump_sects, cmdline_dump_sects,
18028               num_cmdline_dump_sects * sizeof (* dump_sects));
18029     }
18030
18031   if (! process_file_header ())
18032     return FALSE;
18033
18034   if (! process_section_headers (file))
18035     {
18036       /* Without loaded section headers we cannot process lots of things.  */
18037       do_unwind = do_version = do_dump = do_arch = FALSE;
18038
18039       if (! do_using_dynamic)
18040         do_syms = do_dyn_syms = do_reloc = FALSE;
18041     }
18042
18043   if (! process_section_groups (file))
18044     /* Without loaded section groups we cannot process unwind.  */
18045     do_unwind = FALSE;
18046
18047   if (process_program_headers (file))
18048     process_dynamic_section (file);
18049   else
18050     res = FALSE;
18051
18052   if (! process_relocs (file))
18053     res = FALSE;
18054
18055   if (! process_unwind (file))
18056     res = FALSE;
18057
18058   if (! process_symbol_table (file))
18059     res = FALSE;
18060
18061   if (! process_syminfo (file))
18062     res = FALSE;
18063
18064   if (! process_version_sections (file))
18065     res = FALSE;
18066
18067   if (! process_section_contents (file))
18068     res = FALSE;
18069
18070   if (! process_notes (file))
18071     res = FALSE;
18072
18073   if (! process_gnu_liblist (file))
18074     res = FALSE;
18075
18076   if (! process_arch_specific (file))
18077     res = FALSE;
18078
18079   if (program_headers)
18080     {
18081       free (program_headers);
18082       program_headers = NULL;
18083     }
18084
18085   if (section_headers)
18086     {
18087       free (section_headers);
18088       section_headers = NULL;
18089     }
18090
18091   if (string_table)
18092     {
18093       free (string_table);
18094       string_table = NULL;
18095       string_table_length = 0;
18096     }
18097
18098   if (dynamic_strings)
18099     {
18100       free (dynamic_strings);
18101       dynamic_strings = NULL;
18102       dynamic_strings_length = 0;
18103     }
18104
18105   if (dynamic_symbols)
18106     {
18107       free (dynamic_symbols);
18108       dynamic_symbols = NULL;
18109       num_dynamic_syms = 0;
18110     }
18111
18112   if (dynamic_syminfo)
18113     {
18114       free (dynamic_syminfo);
18115       dynamic_syminfo = NULL;
18116     }
18117
18118   if (dynamic_section)
18119     {
18120       free (dynamic_section);
18121       dynamic_section = NULL;
18122     }
18123
18124   if (section_headers_groups)
18125     {
18126       free (section_headers_groups);
18127       section_headers_groups = NULL;
18128     }
18129
18130   if (section_groups)
18131     {
18132       struct group_list * g;
18133       struct group_list * next;
18134
18135       for (i = 0; i < group_count; i++)
18136         {
18137           for (g = section_groups [i].root; g != NULL; g = next)
18138             {
18139               next = g->next;
18140               free (g);
18141             }
18142         }
18143
18144       free (section_groups);
18145       section_groups = NULL;
18146     }
18147
18148   free_debug_memory ();
18149
18150   return res;
18151 }
18152
18153 /* Process an ELF archive.
18154    On entry the file is positioned just after the ARMAG string.
18155    Returns TRUE upon success, FALSE otherwise.  */
18156
18157 static bfd_boolean
18158 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18159 {
18160   struct archive_info arch;
18161   struct archive_info nested_arch;
18162   size_t got;
18163   bfd_boolean ret = TRUE;
18164
18165   show_name = TRUE;
18166
18167   /* The ARCH structure is used to hold information about this archive.  */
18168   arch.file_name = NULL;
18169   arch.file = NULL;
18170   arch.index_array = NULL;
18171   arch.sym_table = NULL;
18172   arch.longnames = NULL;
18173
18174   /* The NESTED_ARCH structure is used as a single-item cache of information
18175      about a nested archive (when members of a thin archive reside within
18176      another regular archive file).  */
18177   nested_arch.file_name = NULL;
18178   nested_arch.file = NULL;
18179   nested_arch.index_array = NULL;
18180   nested_arch.sym_table = NULL;
18181   nested_arch.longnames = NULL;
18182
18183   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18184     {
18185       ret = FALSE;
18186       goto out;
18187     }
18188
18189   if (do_archive_index)
18190     {
18191       if (arch.sym_table == NULL)
18192         error (_("%s: unable to dump the index as none was found\n"), file_name);
18193       else
18194         {
18195           unsigned long i, l;
18196           unsigned long current_pos;
18197
18198           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18199                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18200           current_pos = ftell (file);
18201
18202           for (i = l = 0; i < arch.index_num; i++)
18203             {
18204               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18205                 {
18206                   char * member_name;
18207
18208                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18209
18210                   if (member_name != NULL)
18211                     {
18212                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18213
18214                       if (qualified_name != NULL)
18215                         {
18216                           printf (_("Contents of binary %s at offset "), qualified_name);
18217                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18218                           putchar ('\n');
18219                           free (qualified_name);
18220                         }
18221                     }
18222                 }
18223
18224               if (l >= arch.sym_size)
18225                 {
18226                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18227                          file_name);
18228                   ret = FALSE;
18229                   break;
18230                 }
18231               /* PR 17531: file: 0b6630b2.  */
18232               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18233               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18234             }
18235
18236           if (arch.uses_64bit_indicies)
18237             l = (l + 7) & ~ 7;
18238           else
18239             l += l & 1;
18240
18241           if (l < arch.sym_size)
18242             {
18243               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18244                      file_name, arch.sym_size - l);
18245               ret = FALSE;
18246             }
18247
18248           if (fseek (file, current_pos, SEEK_SET) != 0)
18249             {
18250               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18251               ret = FALSE;
18252               goto out;
18253             }
18254         }
18255
18256       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18257           && !do_segments && !do_header && !do_dump && !do_version
18258           && !do_histogram && !do_debugging && !do_arch && !do_notes
18259           && !do_section_groups && !do_dyn_syms)
18260         {
18261           ret = TRUE; /* Archive index only.  */
18262           goto out;
18263         }
18264     }
18265
18266   while (1)
18267     {
18268       char * name;
18269       size_t namelen;
18270       char * qualified_name;
18271
18272       /* Read the next archive header.  */
18273       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18274         {
18275           error (_("%s: failed to seek to next archive header\n"), file_name);
18276           return FALSE;
18277         }
18278       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18279       if (got != sizeof arch.arhdr)
18280         {
18281           if (got == 0)
18282             break;
18283           error (_("%s: failed to read archive header\n"), file_name);
18284           ret = FALSE;
18285           break;
18286         }
18287       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18288         {
18289           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18290           ret = FALSE;
18291           break;
18292         }
18293
18294       arch.next_arhdr_offset += sizeof arch.arhdr;
18295
18296       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18297       if (archive_file_size & 01)
18298         ++archive_file_size;
18299
18300       name = get_archive_member_name (&arch, &nested_arch);
18301       if (name == NULL)
18302         {
18303           error (_("%s: bad archive file name\n"), file_name);
18304           ret = FALSE;
18305           break;
18306         }
18307       namelen = strlen (name);
18308
18309       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18310       if (qualified_name == NULL)
18311         {
18312           error (_("%s: bad archive file name\n"), file_name);
18313           ret = FALSE;
18314           break;
18315         }
18316
18317       if (is_thin_archive && arch.nested_member_origin == 0)
18318         {
18319           /* This is a proxy for an external member of a thin archive.  */
18320           FILE * member_file;
18321           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18322
18323           if (member_file_name == NULL)
18324             {
18325               ret = FALSE;
18326               break;
18327             }
18328
18329           member_file = fopen (member_file_name, "rb");
18330           if (member_file == NULL)
18331             {
18332               error (_("Input file '%s' is not readable.\n"), member_file_name);
18333               free (member_file_name);
18334               ret = FALSE;
18335               break;
18336             }
18337
18338           archive_file_offset = arch.nested_member_origin;
18339
18340           if (! process_object (qualified_name, member_file))
18341             ret = FALSE;
18342
18343           fclose (member_file);
18344           free (member_file_name);
18345         }
18346       else if (is_thin_archive)
18347         {
18348           /* PR 15140: Allow for corrupt thin archives.  */
18349           if (nested_arch.file == NULL)
18350             {
18351               error (_("%s: contains corrupt thin archive: %s\n"),
18352                      file_name, name);
18353               ret = FALSE;
18354               break;
18355             }
18356
18357           /* This is a proxy for a member of a nested archive.  */
18358           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18359
18360           /* The nested archive file will have been opened and setup by
18361              get_archive_member_name.  */
18362           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18363             {
18364               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18365               ret = FALSE;
18366               break;
18367             }
18368
18369           if (! process_object (qualified_name, nested_arch.file))
18370             ret = FALSE;
18371         }
18372       else
18373         {
18374           archive_file_offset = arch.next_arhdr_offset;
18375           arch.next_arhdr_offset += archive_file_size;
18376
18377           if (! process_object (qualified_name, file))
18378             ret = FALSE;
18379         }
18380
18381       if (dump_sects != NULL)
18382         {
18383           free (dump_sects);
18384           dump_sects = NULL;
18385           num_dump_sects = 0;
18386         }
18387
18388       free (qualified_name);
18389     }
18390
18391  out:
18392   if (nested_arch.file != NULL)
18393     fclose (nested_arch.file);
18394   release_archive (&nested_arch);
18395   release_archive (&arch);
18396
18397   return ret;
18398 }
18399
18400 static bfd_boolean
18401 process_file (char * file_name)
18402 {
18403   FILE * file;
18404   struct stat statbuf;
18405   char armag[SARMAG];
18406   bfd_boolean ret = TRUE;
18407
18408   if (stat (file_name, &statbuf) < 0)
18409     {
18410       if (errno == ENOENT)
18411         error (_("'%s': No such file\n"), file_name);
18412       else
18413         error (_("Could not locate '%s'.  System error message: %s\n"),
18414                file_name, strerror (errno));
18415       return FALSE;
18416     }
18417
18418   if (! S_ISREG (statbuf.st_mode))
18419     {
18420       error (_("'%s' is not an ordinary file\n"), file_name);
18421       return FALSE;
18422     }
18423
18424   file = fopen (file_name, "rb");
18425   if (file == NULL)
18426     {
18427       error (_("Input file '%s' is not readable.\n"), file_name);
18428       return FALSE;
18429     }
18430
18431   if (fread (armag, SARMAG, 1, file) != 1)
18432     {
18433       error (_("%s: Failed to read file's magic number\n"), file_name);
18434       fclose (file);
18435       return FALSE;
18436     }
18437
18438   current_file_size = (bfd_size_type) statbuf.st_size;
18439
18440   if (memcmp (armag, ARMAG, SARMAG) == 0)
18441     {
18442       if (! process_archive (file_name, file, FALSE))
18443         ret = FALSE;
18444     }
18445   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18446     {
18447       if ( ! process_archive (file_name, file, TRUE))
18448         ret = FALSE;
18449     }
18450   else
18451     {
18452       if (do_archive_index)
18453         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18454                file_name);
18455
18456       rewind (file);
18457       archive_file_size = archive_file_offset = 0;
18458
18459       if (! process_object (file_name, file))
18460         ret = FALSE;
18461     }
18462
18463   fclose (file);
18464   current_file_size = 0;
18465
18466   return ret;
18467 }
18468
18469 #ifdef SUPPORT_DISASSEMBLY
18470 /* Needed by the i386 disassembler.  For extra credit, someone could
18471    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18472    symbols.  */
18473
18474 void
18475 print_address (unsigned int addr, FILE * outfile)
18476 {
18477   fprintf (outfile,"0x%8.8x", addr);
18478 }
18479
18480 /* Needed by the i386 disassembler.  */
18481 void
18482 db_task_printsym (unsigned int addr)
18483 {
18484   print_address (addr, stderr);
18485 }
18486 #endif
18487
18488 int
18489 main (int argc, char ** argv)
18490 {
18491   int err;
18492
18493 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18494   setlocale (LC_MESSAGES, "");
18495 #endif
18496 #if defined (HAVE_SETLOCALE)
18497   setlocale (LC_CTYPE, "");
18498 #endif
18499   bindtextdomain (PACKAGE, LOCALEDIR);
18500   textdomain (PACKAGE);
18501
18502   expandargv (&argc, &argv);
18503
18504   parse_args (argc, argv);
18505
18506   if (num_dump_sects > 0)
18507     {
18508       /* Make a copy of the dump_sects array.  */
18509       cmdline_dump_sects = (dump_type *)
18510           malloc (num_dump_sects * sizeof (* dump_sects));
18511       if (cmdline_dump_sects == NULL)
18512         error (_("Out of memory allocating dump request table.\n"));
18513       else
18514         {
18515           memcpy (cmdline_dump_sects, dump_sects,
18516                   num_dump_sects * sizeof (* dump_sects));
18517           num_cmdline_dump_sects = num_dump_sects;
18518         }
18519     }
18520
18521   if (optind < (argc - 1))
18522     show_name = TRUE;
18523   else if (optind >= argc)
18524     {
18525       warn (_("Nothing to do.\n"));
18526       usage (stderr);
18527     }
18528
18529   err = FALSE;
18530   while (optind < argc)
18531     if (! process_file (argv[optind++]))
18532       err = TRUE;
18533
18534   if (dump_sects != NULL)
18535     free (dump_sects);
18536   if (cmdline_dump_sects != NULL)
18537     free (cmdline_dump_sects);
18538
18539   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18540 }