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 0:
3338             /* We simply ignore the field in this case to avoid confusion:
3339                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3340                extension.  */
3341               break;
3342             default: strcat (buf, _(", unknown CPU")); break;
3343             }
3344
3345           switch ((e_flags & EF_MIPS_ABI))
3346             {
3347             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3348             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3349             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3350             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3351             case 0:
3352             /* We simply ignore the field in this case to avoid confusion:
3353                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3354                This means it is likely to be an o32 file, but not for
3355                sure.  */
3356               break;
3357             default: strcat (buf, _(", unknown ABI")); break;
3358             }
3359
3360           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3361             strcat (buf, ", mdmx");
3362
3363           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3364             strcat (buf, ", mips16");
3365
3366           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3367             strcat (buf, ", micromips");
3368
3369           switch ((e_flags & EF_MIPS_ARCH))
3370             {
3371             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3372             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3373             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3374             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3375             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3376             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3377             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3378             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3379             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3380             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3381             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3382             default: strcat (buf, _(", unknown ISA")); break;
3383             }
3384           break;
3385
3386         case EM_NDS32:
3387           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3388           break;
3389
3390         case EM_RISCV:
3391           if (e_flags & EF_RISCV_RVC)
3392             strcat (buf, ", RVC");
3393
3394           switch (e_flags & EF_RISCV_FLOAT_ABI)
3395             {
3396             case EF_RISCV_FLOAT_ABI_SOFT:
3397               strcat (buf, ", soft-float ABI");
3398               break;
3399
3400             case EF_RISCV_FLOAT_ABI_SINGLE:
3401               strcat (buf, ", single-float ABI");
3402               break;
3403
3404             case EF_RISCV_FLOAT_ABI_DOUBLE:
3405               strcat (buf, ", double-float ABI");
3406               break;
3407
3408             case EF_RISCV_FLOAT_ABI_QUAD:
3409               strcat (buf, ", quad-float ABI");
3410               break;
3411             }
3412           break;
3413
3414         case EM_SH:
3415           switch ((e_flags & EF_SH_MACH_MASK))
3416             {
3417             case EF_SH1: strcat (buf, ", sh1"); break;
3418             case EF_SH2: strcat (buf, ", sh2"); break;
3419             case EF_SH3: strcat (buf, ", sh3"); break;
3420             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3421             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3422             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3423             case EF_SH3E: strcat (buf, ", sh3e"); break;
3424             case EF_SH4: strcat (buf, ", sh4"); break;
3425             case EF_SH5: strcat (buf, ", sh5"); break;
3426             case EF_SH2E: strcat (buf, ", sh2e"); break;
3427             case EF_SH4A: strcat (buf, ", sh4a"); break;
3428             case EF_SH2A: strcat (buf, ", sh2a"); break;
3429             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3430             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3431             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3432             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3433             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3434             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3435             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3436             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3437             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3438             default: strcat (buf, _(", unknown ISA")); break;
3439             }
3440
3441           if (e_flags & EF_SH_PIC)
3442             strcat (buf, ", pic");
3443
3444           if (e_flags & EF_SH_FDPIC)
3445             strcat (buf, ", fdpic");
3446           break;
3447
3448         case EM_OR1K:
3449           if (e_flags & EF_OR1K_NODELAY)
3450             strcat (buf, ", no delay");
3451           break;
3452
3453         case EM_SPARCV9:
3454           if (e_flags & EF_SPARC_32PLUS)
3455             strcat (buf, ", v8+");
3456
3457           if (e_flags & EF_SPARC_SUN_US1)
3458             strcat (buf, ", ultrasparcI");
3459
3460           if (e_flags & EF_SPARC_SUN_US3)
3461             strcat (buf, ", ultrasparcIII");
3462
3463           if (e_flags & EF_SPARC_HAL_R1)
3464             strcat (buf, ", halr1");
3465
3466           if (e_flags & EF_SPARC_LEDATA)
3467             strcat (buf, ", ledata");
3468
3469           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3470             strcat (buf, ", tso");
3471
3472           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3473             strcat (buf, ", pso");
3474
3475           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3476             strcat (buf, ", rmo");
3477           break;
3478
3479         case EM_PARISC:
3480           switch (e_flags & EF_PARISC_ARCH)
3481             {
3482             case EFA_PARISC_1_0:
3483               strcpy (buf, ", PA-RISC 1.0");
3484               break;
3485             case EFA_PARISC_1_1:
3486               strcpy (buf, ", PA-RISC 1.1");
3487               break;
3488             case EFA_PARISC_2_0:
3489               strcpy (buf, ", PA-RISC 2.0");
3490               break;
3491             default:
3492               break;
3493             }
3494           if (e_flags & EF_PARISC_TRAPNIL)
3495             strcat (buf, ", trapnil");
3496           if (e_flags & EF_PARISC_EXT)
3497             strcat (buf, ", ext");
3498           if (e_flags & EF_PARISC_LSB)
3499             strcat (buf, ", lsb");
3500           if (e_flags & EF_PARISC_WIDE)
3501             strcat (buf, ", wide");
3502           if (e_flags & EF_PARISC_NO_KABP)
3503             strcat (buf, ", no kabp");
3504           if (e_flags & EF_PARISC_LAZYSWAP)
3505             strcat (buf, ", lazyswap");
3506           break;
3507
3508         case EM_PJ:
3509         case EM_PJ_OLD:
3510           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3511             strcat (buf, ", new calling convention");
3512
3513           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3514             strcat (buf, ", gnu calling convention");
3515           break;
3516
3517         case EM_IA_64:
3518           if ((e_flags & EF_IA_64_ABI64))
3519             strcat (buf, ", 64-bit");
3520           else
3521             strcat (buf, ", 32-bit");
3522           if ((e_flags & EF_IA_64_REDUCEDFP))
3523             strcat (buf, ", reduced fp model");
3524           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3525             strcat (buf, ", no function descriptors, constant gp");
3526           else if ((e_flags & EF_IA_64_CONS_GP))
3527             strcat (buf, ", constant gp");
3528           if ((e_flags & EF_IA_64_ABSOLUTE))
3529             strcat (buf, ", absolute");
3530           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3531             {
3532               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3533                 strcat (buf, ", vms_linkages");
3534               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3535                 {
3536                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3537                   break;
3538                 case EF_IA_64_VMS_COMCOD_WARNING:
3539                   strcat (buf, ", warning");
3540                   break;
3541                 case EF_IA_64_VMS_COMCOD_ERROR:
3542                   strcat (buf, ", error");
3543                   break;
3544                 case EF_IA_64_VMS_COMCOD_ABORT:
3545                   strcat (buf, ", abort");
3546                   break;
3547                 default:
3548                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3549                         e_flags & EF_IA_64_VMS_COMCOD);
3550                   strcat (buf, ", <unknown>");
3551                 }
3552             }
3553           break;
3554
3555         case EM_VAX:
3556           if ((e_flags & EF_VAX_NONPIC))
3557             strcat (buf, ", non-PIC");
3558           if ((e_flags & EF_VAX_DFLOAT))
3559             strcat (buf, ", D-Float");
3560           if ((e_flags & EF_VAX_GFLOAT))
3561             strcat (buf, ", G-Float");
3562           break;
3563
3564         case EM_VISIUM:
3565           if (e_flags & EF_VISIUM_ARCH_MCM)
3566             strcat (buf, ", mcm");
3567           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3568             strcat (buf, ", mcm24");
3569           if (e_flags & EF_VISIUM_ARCH_GR6)
3570             strcat (buf, ", gr6");
3571           break;
3572
3573         case EM_RL78:
3574           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3575             {
3576             case E_FLAG_RL78_ANY_CPU: break;
3577             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3578             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3579             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3580             }
3581           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3582             strcat (buf, ", 64-bit doubles");
3583           break;
3584
3585         case EM_RX:
3586           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3587             strcat (buf, ", 64-bit doubles");
3588           if (e_flags & E_FLAG_RX_DSP)
3589             strcat (buf, ", dsp");
3590           if (e_flags & E_FLAG_RX_PID)
3591             strcat (buf, ", pid");
3592           if (e_flags & E_FLAG_RX_ABI)
3593             strcat (buf, ", RX ABI");
3594           if (e_flags & E_FLAG_RX_SINSNS_SET)
3595             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3596                     ? ", uses String instructions" : ", bans String instructions");
3597           if (e_flags & E_FLAG_RX_V2)
3598             strcat (buf, ", V2");
3599           break;
3600
3601         case EM_S390:
3602           if (e_flags & EF_S390_HIGH_GPRS)
3603             strcat (buf, ", highgprs");
3604           break;
3605
3606         case EM_TI_C6000:
3607           if ((e_flags & EF_C6000_REL))
3608             strcat (buf, ", relocatable module");
3609           break;
3610
3611         case EM_MSP430:
3612           strcat (buf, _(": architecture variant: "));
3613           switch (e_flags & EF_MSP430_MACH)
3614             {
3615             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3616             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3617             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3618             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3619             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3620             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3621             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3622             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3623             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3624             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3625             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3626             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3627             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3628             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3629             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3630             default:
3631               strcat (buf, _(": unknown")); break;
3632             }
3633
3634           if (e_flags & ~ EF_MSP430_MACH)
3635             strcat (buf, _(": unknown extra flag bits also present"));
3636         }
3637     }
3638
3639   return buf;
3640 }
3641
3642 static const char *
3643 get_osabi_name (unsigned int osabi)
3644 {
3645   static char buff[32];
3646
3647   switch (osabi)
3648     {
3649     case ELFOSABI_NONE:         return "UNIX - System V";
3650     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3651     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3652     case ELFOSABI_GNU:          return "UNIX - GNU";
3653     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3654     case ELFOSABI_AIX:          return "UNIX - AIX";
3655     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3656     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3657     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3658     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3659     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3660     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3661     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3662     case ELFOSABI_AROS:         return "AROS";
3663     case ELFOSABI_FENIXOS:      return "FenixOS";
3664     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3665     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3666     default:
3667       if (osabi >= 64)
3668         switch (elf_header.e_machine)
3669           {
3670           case EM_ARM:
3671             switch (osabi)
3672               {
3673               case ELFOSABI_ARM:        return "ARM";
3674               default:
3675                 break;
3676               }
3677             break;
3678
3679           case EM_MSP430:
3680           case EM_MSP430_OLD:
3681           case EM_VISIUM:
3682             switch (osabi)
3683               {
3684               case ELFOSABI_STANDALONE: return _("Standalone App");
3685               default:
3686                 break;
3687               }
3688             break;
3689
3690           case EM_TI_C6000:
3691             switch (osabi)
3692               {
3693               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3694               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3695               default:
3696                 break;
3697               }
3698             break;
3699
3700           default:
3701             break;
3702           }
3703       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3704       return buff;
3705     }
3706 }
3707
3708 static const char *
3709 get_aarch64_segment_type (unsigned long type)
3710 {
3711   switch (type)
3712     {
3713     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3714     default:                  return NULL;
3715     }
3716 }
3717
3718 static const char *
3719 get_arm_segment_type (unsigned long type)
3720 {
3721   switch (type)
3722     {
3723     case PT_ARM_EXIDX: return "EXIDX";
3724     default:           return NULL;
3725     }
3726 }
3727
3728 static const char *
3729 get_mips_segment_type (unsigned long type)
3730 {
3731   switch (type)
3732     {
3733     case PT_MIPS_REGINFO:   return "REGINFO";
3734     case PT_MIPS_RTPROC:    return "RTPROC";
3735     case PT_MIPS_OPTIONS:   return "OPTIONS";
3736     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3737     default:                return NULL;
3738     }
3739 }
3740
3741 static const char *
3742 get_parisc_segment_type (unsigned long type)
3743 {
3744   switch (type)
3745     {
3746     case PT_HP_TLS:             return "HP_TLS";
3747     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3748     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3749     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3750     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3751     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3752     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3753     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3754     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3755     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3756     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3757     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3758     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3759     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3760     case PT_HP_STACK:           return "HP_STACK";
3761     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3762     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3763     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3764     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3765     default:                    return NULL;
3766     }
3767 }
3768
3769 static const char *
3770 get_ia64_segment_type (unsigned long type)
3771 {
3772   switch (type)
3773     {
3774     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3775     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3776     case PT_HP_TLS:             return "HP_TLS";
3777     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3778     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3779     case PT_IA_64_HP_STACK:     return "HP_STACK";
3780     default:                    return NULL;
3781     }
3782 }
3783
3784 static const char *
3785 get_tic6x_segment_type (unsigned long type)
3786 {
3787   switch (type)
3788     {
3789     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3790     default:               return NULL;
3791     }
3792 }
3793
3794 static const char *
3795 get_solaris_segment_type (unsigned long type)
3796 {
3797   switch (type)
3798     {
3799     case 0x6464e550: return "PT_SUNW_UNWIND";
3800     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3801     case 0x6ffffff7: return "PT_LOSUNW";
3802     case 0x6ffffffa: return "PT_SUNWBSS";
3803     case 0x6ffffffb: return "PT_SUNWSTACK";
3804     case 0x6ffffffc: return "PT_SUNWDTRACE";
3805     case 0x6ffffffd: return "PT_SUNWCAP";
3806     case 0x6fffffff: return "PT_HISUNW";
3807     default:         return NULL;
3808     }
3809 }
3810
3811 static const char *
3812 get_segment_type (unsigned long p_type)
3813 {
3814   static char buff[32];
3815
3816   switch (p_type)
3817     {
3818     case PT_NULL:       return "NULL";
3819     case PT_LOAD:       return "LOAD";
3820     case PT_DYNAMIC:    return "DYNAMIC";
3821     case PT_INTERP:     return "INTERP";
3822     case PT_NOTE:       return "NOTE";
3823     case PT_SHLIB:      return "SHLIB";
3824     case PT_PHDR:       return "PHDR";
3825     case PT_TLS:        return "TLS";
3826     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3827     case PT_GNU_STACK:  return "GNU_STACK";
3828     case PT_GNU_RELRO:  return "GNU_RELRO";
3829
3830     default:
3831       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3832         {
3833           sprintf (buff, "GNU_MBIND+%#lx",
3834                    p_type - PT_GNU_MBIND_LO);
3835         }
3836       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3837         {
3838           const char * result;
3839
3840           switch (elf_header.e_machine)
3841             {
3842             case EM_AARCH64:
3843               result = get_aarch64_segment_type (p_type);
3844               break;
3845             case EM_ARM:
3846               result = get_arm_segment_type (p_type);
3847               break;
3848             case EM_MIPS:
3849             case EM_MIPS_RS3_LE:
3850               result = get_mips_segment_type (p_type);
3851               break;
3852             case EM_PARISC:
3853               result = get_parisc_segment_type (p_type);
3854               break;
3855             case EM_IA_64:
3856               result = get_ia64_segment_type (p_type);
3857               break;
3858             case EM_TI_C6000:
3859               result = get_tic6x_segment_type (p_type);
3860               break;
3861             default:
3862               result = NULL;
3863               break;
3864             }
3865
3866           if (result != NULL)
3867             return result;
3868
3869           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3870         }
3871       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3872         {
3873           const char * result;
3874
3875           switch (elf_header.e_machine)
3876             {
3877             case EM_PARISC:
3878               result = get_parisc_segment_type (p_type);
3879               break;
3880             case EM_IA_64:
3881               result = get_ia64_segment_type (p_type);
3882               break;
3883             default:
3884               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3885                 result = get_solaris_segment_type (p_type);
3886               else
3887                 result = NULL;
3888               break;
3889             }
3890
3891           if (result != NULL)
3892             return result;
3893
3894           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3895         }
3896       else
3897         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3898
3899       return buff;
3900     }
3901 }
3902
3903 static const char *
3904 get_arc_section_type_name (unsigned int sh_type)
3905 {
3906   switch (sh_type)
3907     {
3908     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3909     default:
3910       break;
3911     }
3912   return NULL;
3913 }
3914
3915 static const char *
3916 get_mips_section_type_name (unsigned int sh_type)
3917 {
3918   switch (sh_type)
3919     {
3920     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3921     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3922     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3923     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3924     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3925     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3926     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3927     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3928     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3929     case SHT_MIPS_RELD:          return "MIPS_RELD";
3930     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3931     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3932     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3933     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3934     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3935     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3936     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3937     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3938     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3939     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3940     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3941     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3942     case SHT_MIPS_LINE:          return "MIPS_LINE";
3943     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3944     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3945     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3946     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3947     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3948     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3949     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3950     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3951     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3952     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3953     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3954     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3955     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3956     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3957     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3958     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3959     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3960     default:
3961       break;
3962     }
3963   return NULL;
3964 }
3965
3966 static const char *
3967 get_parisc_section_type_name (unsigned int sh_type)
3968 {
3969   switch (sh_type)
3970     {
3971     case SHT_PARISC_EXT:        return "PARISC_EXT";
3972     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3973     case SHT_PARISC_DOC:        return "PARISC_DOC";
3974     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3975     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3976     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3977     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3978     default:                    return NULL;
3979     }
3980 }
3981
3982 static const char *
3983 get_ia64_section_type_name (unsigned int sh_type)
3984 {
3985   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3986   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3987     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3988
3989   switch (sh_type)
3990     {
3991     case SHT_IA_64_EXT:                return "IA_64_EXT";
3992     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3993     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3994     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3995     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3996     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3997     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3998     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3999     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4000     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4001     default:
4002       break;
4003     }
4004   return NULL;
4005 }
4006
4007 static const char *
4008 get_x86_64_section_type_name (unsigned int sh_type)
4009 {
4010   switch (sh_type)
4011     {
4012     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4013     default:                    return NULL;
4014     }
4015 }
4016
4017 static const char *
4018 get_aarch64_section_type_name (unsigned int sh_type)
4019 {
4020   switch (sh_type)
4021     {
4022     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4023     default:                     return NULL;
4024     }
4025 }
4026
4027 static const char *
4028 get_arm_section_type_name (unsigned int sh_type)
4029 {
4030   switch (sh_type)
4031     {
4032     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4033     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4034     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4035     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4036     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4037     default:                      return NULL;
4038     }
4039 }
4040
4041 static const char *
4042 get_tic6x_section_type_name (unsigned int sh_type)
4043 {
4044   switch (sh_type)
4045     {
4046     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4047     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4048     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4049     case SHT_TI_ICODE:          return "TI_ICODE";
4050     case SHT_TI_XREF:           return "TI_XREF";
4051     case SHT_TI_HANDLER:        return "TI_HANDLER";
4052     case SHT_TI_INITINFO:       return "TI_INITINFO";
4053     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4054     default:                    return NULL;
4055     }
4056 }
4057
4058 static const char *
4059 get_msp430x_section_type_name (unsigned int sh_type)
4060 {
4061   switch (sh_type)
4062     {
4063     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4064     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4065     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4066     default:                      return NULL;
4067     }
4068 }
4069
4070 static const char *
4071 get_v850_section_type_name (unsigned int sh_type)
4072 {
4073   switch (sh_type)
4074     {
4075     case SHT_V850_SCOMMON:  return "V850 Small Common";
4076     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4077     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4078     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4079     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4080     default:                return NULL;
4081     }
4082 }
4083
4084 static const char *
4085 get_section_type_name (unsigned int sh_type)
4086 {
4087   static char buff[32];
4088   const char * result;
4089
4090   switch (sh_type)
4091     {
4092     case SHT_NULL:              return "NULL";
4093     case SHT_PROGBITS:          return "PROGBITS";
4094     case SHT_SYMTAB:            return "SYMTAB";
4095     case SHT_STRTAB:            return "STRTAB";
4096     case SHT_RELA:              return "RELA";
4097     case SHT_HASH:              return "HASH";
4098     case SHT_DYNAMIC:           return "DYNAMIC";
4099     case SHT_NOTE:              return "NOTE";
4100     case SHT_NOBITS:            return "NOBITS";
4101     case SHT_REL:               return "REL";
4102     case SHT_SHLIB:             return "SHLIB";
4103     case SHT_DYNSYM:            return "DYNSYM";
4104     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4105     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4106     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4107     case SHT_GNU_HASH:          return "GNU_HASH";
4108     case SHT_GROUP:             return "GROUP";
4109     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4110     case SHT_GNU_verdef:        return "VERDEF";
4111     case SHT_GNU_verneed:       return "VERNEED";
4112     case SHT_GNU_versym:        return "VERSYM";
4113     case 0x6ffffff0:            return "VERSYM";
4114     case 0x6ffffffc:            return "VERDEF";
4115     case 0x7ffffffd:            return "AUXILIARY";
4116     case 0x7fffffff:            return "FILTER";
4117     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4118
4119     default:
4120       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4121         {
4122           switch (elf_header.e_machine)
4123             {
4124             case EM_ARC:
4125             case EM_ARC_COMPACT:
4126             case EM_ARC_COMPACT2:
4127               result = get_arc_section_type_name (sh_type);
4128               break;
4129             case EM_MIPS:
4130             case EM_MIPS_RS3_LE:
4131               result = get_mips_section_type_name (sh_type);
4132               break;
4133             case EM_PARISC:
4134               result = get_parisc_section_type_name (sh_type);
4135               break;
4136             case EM_IA_64:
4137               result = get_ia64_section_type_name (sh_type);
4138               break;
4139             case EM_X86_64:
4140             case EM_L1OM:
4141             case EM_K1OM:
4142               result = get_x86_64_section_type_name (sh_type);
4143               break;
4144             case EM_AARCH64:
4145               result = get_aarch64_section_type_name (sh_type);
4146               break;
4147             case EM_ARM:
4148               result = get_arm_section_type_name (sh_type);
4149               break;
4150             case EM_TI_C6000:
4151               result = get_tic6x_section_type_name (sh_type);
4152               break;
4153             case EM_MSP430:
4154               result = get_msp430x_section_type_name (sh_type);
4155               break;
4156             case EM_V800:
4157             case EM_V850:
4158             case EM_CYGNUS_V850:
4159               result = get_v850_section_type_name (sh_type);
4160               break;
4161             default:
4162               result = NULL;
4163               break;
4164             }
4165
4166           if (result != NULL)
4167             return result;
4168
4169           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4170         }
4171       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4172         {
4173           switch (elf_header.e_machine)
4174             {
4175             case EM_IA_64:
4176               result = get_ia64_section_type_name (sh_type);
4177               break;
4178             default:
4179               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4180                 result = get_solaris_section_type (sh_type);
4181               else
4182                 {
4183                   switch (sh_type)
4184                     {
4185                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4186                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4187                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4188                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4189                     default:
4190                       result = NULL;
4191                       break;
4192                     }
4193                 }
4194               break;
4195             }
4196
4197           if (result != NULL)
4198             return result;
4199
4200           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4201         }
4202       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4203         {
4204           switch (elf_header.e_machine)
4205             {
4206             case EM_V800:
4207             case EM_V850:
4208             case EM_CYGNUS_V850:
4209               result = get_v850_section_type_name (sh_type);
4210               break;
4211             default:
4212               result = NULL;
4213               break;
4214             }
4215
4216           if (result != NULL)
4217             return result;
4218
4219           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4220         }
4221       else
4222         /* This message is probably going to be displayed in a 15
4223            character wide field, so put the hex value first.  */
4224         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4225
4226       return buff;
4227     }
4228 }
4229
4230 #define OPTION_DEBUG_DUMP       512
4231 #define OPTION_DYN_SYMS         513
4232 #define OPTION_DWARF_DEPTH      514
4233 #define OPTION_DWARF_START      515
4234 #define OPTION_DWARF_CHECK      516
4235
4236 static struct option options[] =
4237 {
4238   {"all",              no_argument, 0, 'a'},
4239   {"file-header",      no_argument, 0, 'h'},
4240   {"program-headers",  no_argument, 0, 'l'},
4241   {"headers",          no_argument, 0, 'e'},
4242   {"histogram",        no_argument, 0, 'I'},
4243   {"segments",         no_argument, 0, 'l'},
4244   {"sections",         no_argument, 0, 'S'},
4245   {"section-headers",  no_argument, 0, 'S'},
4246   {"section-groups",   no_argument, 0, 'g'},
4247   {"section-details",  no_argument, 0, 't'},
4248   {"full-section-name",no_argument, 0, 'N'},
4249   {"symbols",          no_argument, 0, 's'},
4250   {"syms",             no_argument, 0, 's'},
4251   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4252   {"relocs",           no_argument, 0, 'r'},
4253   {"notes",            no_argument, 0, 'n'},
4254   {"dynamic",          no_argument, 0, 'd'},
4255   {"arch-specific",    no_argument, 0, 'A'},
4256   {"version-info",     no_argument, 0, 'V'},
4257   {"use-dynamic",      no_argument, 0, 'D'},
4258   {"unwind",           no_argument, 0, 'u'},
4259   {"archive-index",    no_argument, 0, 'c'},
4260   {"hex-dump",         required_argument, 0, 'x'},
4261   {"relocated-dump",   required_argument, 0, 'R'},
4262   {"string-dump",      required_argument, 0, 'p'},
4263   {"decompress",       no_argument, 0, 'z'},
4264 #ifdef SUPPORT_DISASSEMBLY
4265   {"instruction-dump", required_argument, 0, 'i'},
4266 #endif
4267   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4268
4269   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4270   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4271   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4272
4273   {"version",          no_argument, 0, 'v'},
4274   {"wide",             no_argument, 0, 'W'},
4275   {"help",             no_argument, 0, 'H'},
4276   {0,                  no_argument, 0, 0}
4277 };
4278
4279 static void
4280 usage (FILE * stream)
4281 {
4282   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4283   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4284   fprintf (stream, _(" Options are:\n\
4285   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4286   -h --file-header       Display the ELF file header\n\
4287   -l --program-headers   Display the program headers\n\
4288      --segments          An alias for --program-headers\n\
4289   -S --section-headers   Display the sections' header\n\
4290      --sections          An alias for --section-headers\n\
4291   -g --section-groups    Display the section groups\n\
4292   -t --section-details   Display the section details\n\
4293   -e --headers           Equivalent to: -h -l -S\n\
4294   -s --syms              Display the symbol table\n\
4295      --symbols           An alias for --syms\n\
4296   --dyn-syms             Display the dynamic symbol table\n\
4297   -n --notes             Display the core notes (if present)\n\
4298   -r --relocs            Display the relocations (if present)\n\
4299   -u --unwind            Display the unwind info (if present)\n\
4300   -d --dynamic           Display the dynamic section (if present)\n\
4301   -V --version-info      Display the version sections (if present)\n\
4302   -A --arch-specific     Display architecture specific information (if any)\n\
4303   -c --archive-index     Display the symbol/file index in an archive\n\
4304   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4305   -x --hex-dump=<number|name>\n\
4306                          Dump the contents of section <number|name> as bytes\n\
4307   -p --string-dump=<number|name>\n\
4308                          Dump the contents of section <number|name> as strings\n\
4309   -R --relocated-dump=<number|name>\n\
4310                          Dump the contents of section <number|name> as relocated bytes\n\
4311   -z --decompress        Decompress section before dumping it\n\
4312   -w[lLiaprmfFsoRt] or\n\
4313   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4314                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4315                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4316                =addr,=cu_index]\n\
4317                          Display the contents of DWARF2 debug sections\n"));
4318   fprintf (stream, _("\
4319   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4320   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4321                          or deeper\n"));
4322 #ifdef SUPPORT_DISASSEMBLY
4323   fprintf (stream, _("\
4324   -i --instruction-dump=<number|name>\n\
4325                          Disassemble the contents of section <number|name>\n"));
4326 #endif
4327   fprintf (stream, _("\
4328   -I --histogram         Display histogram of bucket list lengths\n\
4329   -W --wide              Allow output width to exceed 80 characters\n\
4330   @<file>                Read options from <file>\n\
4331   -H --help              Display this information\n\
4332   -v --version           Display the version number of readelf\n"));
4333
4334   if (REPORT_BUGS_TO[0] && stream == stdout)
4335     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4336
4337   exit (stream == stdout ? 0 : 1);
4338 }
4339
4340 /* Record the fact that the user wants the contents of section number
4341    SECTION to be displayed using the method(s) encoded as flags bits
4342    in TYPE.  Note, TYPE can be zero if we are creating the array for
4343    the first time.  */
4344
4345 static void
4346 request_dump_bynumber (unsigned int section, dump_type type)
4347 {
4348   if (section >= num_dump_sects)
4349     {
4350       dump_type * new_dump_sects;
4351
4352       new_dump_sects = (dump_type *) calloc (section + 1,
4353                                              sizeof (* dump_sects));
4354
4355       if (new_dump_sects == NULL)
4356         error (_("Out of memory allocating dump request table.\n"));
4357       else
4358         {
4359           if (dump_sects)
4360             {
4361               /* Copy current flag settings.  */
4362               memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4363
4364               free (dump_sects);
4365             }
4366
4367           dump_sects = new_dump_sects;
4368           num_dump_sects = section + 1;
4369         }
4370     }
4371
4372   if (dump_sects)
4373     dump_sects[section] |= type;
4374
4375   return;
4376 }
4377
4378 /* Request a dump by section name.  */
4379
4380 static void
4381 request_dump_byname (const char * section, dump_type type)
4382 {
4383   struct dump_list_entry * new_request;
4384
4385   new_request = (struct dump_list_entry *)
4386       malloc (sizeof (struct dump_list_entry));
4387   if (!new_request)
4388     error (_("Out of memory allocating dump request table.\n"));
4389
4390   new_request->name = strdup (section);
4391   if (!new_request->name)
4392     error (_("Out of memory allocating dump request table.\n"));
4393
4394   new_request->type = type;
4395
4396   new_request->next = dump_sects_byname;
4397   dump_sects_byname = new_request;
4398 }
4399
4400 static inline void
4401 request_dump (dump_type type)
4402 {
4403   int section;
4404   char * cp;
4405
4406   do_dump++;
4407   section = strtoul (optarg, & cp, 0);
4408
4409   if (! *cp && section >= 0)
4410     request_dump_bynumber (section, type);
4411   else
4412     request_dump_byname (optarg, type);
4413 }
4414
4415
4416 static void
4417 parse_args (int argc, char ** argv)
4418 {
4419   int c;
4420
4421   if (argc < 2)
4422     usage (stderr);
4423
4424   while ((c = getopt_long
4425           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4426     {
4427       switch (c)
4428         {
4429         case 0:
4430           /* Long options.  */
4431           break;
4432         case 'H':
4433           usage (stdout);
4434           break;
4435
4436         case 'a':
4437           do_syms = TRUE;
4438           do_reloc = TRUE;
4439           do_unwind = TRUE;
4440           do_dynamic = TRUE;
4441           do_header = TRUE;
4442           do_sections = TRUE;
4443           do_section_groups = TRUE;
4444           do_segments = TRUE;
4445           do_version = TRUE;
4446           do_histogram = TRUE;
4447           do_arch = TRUE;
4448           do_notes = TRUE;
4449           break;
4450         case 'g':
4451           do_section_groups = TRUE;
4452           break;
4453         case 't':
4454         case 'N':
4455           do_sections = TRUE;
4456           do_section_details = TRUE;
4457           break;
4458         case 'e':
4459           do_header = TRUE;
4460           do_sections = TRUE;
4461           do_segments = TRUE;
4462           break;
4463         case 'A':
4464           do_arch = TRUE;
4465           break;
4466         case 'D':
4467           do_using_dynamic = TRUE;
4468           break;
4469         case 'r':
4470           do_reloc = TRUE;
4471           break;
4472         case 'u':
4473           do_unwind = TRUE;
4474           break;
4475         case 'h':
4476           do_header = TRUE;
4477           break;
4478         case 'l':
4479           do_segments = TRUE;
4480           break;
4481         case 's':
4482           do_syms = TRUE;
4483           break;
4484         case 'S':
4485           do_sections = TRUE;
4486           break;
4487         case 'd':
4488           do_dynamic = TRUE;
4489           break;
4490         case 'I':
4491           do_histogram = TRUE;
4492           break;
4493         case 'n':
4494           do_notes = TRUE;
4495           break;
4496         case 'c':
4497           do_archive_index = TRUE;
4498           break;
4499         case 'x':
4500           request_dump (HEX_DUMP);
4501           break;
4502         case 'p':
4503           request_dump (STRING_DUMP);
4504           break;
4505         case 'R':
4506           request_dump (RELOC_DUMP);
4507           break;
4508         case 'z':
4509           decompress_dumps = TRUE;
4510           break;
4511         case 'w':
4512           do_dump = TRUE;
4513           if (optarg == 0)
4514             {
4515               do_debugging = TRUE;
4516               dwarf_select_sections_all ();
4517             }
4518           else
4519             {
4520               do_debugging = FALSE;
4521               dwarf_select_sections_by_letters (optarg);
4522             }
4523           break;
4524         case OPTION_DEBUG_DUMP:
4525           do_dump = TRUE;
4526           if (optarg == 0)
4527             do_debugging = TRUE;
4528           else
4529             {
4530               do_debugging = FALSE;
4531               dwarf_select_sections_by_names (optarg);
4532             }
4533           break;
4534         case OPTION_DWARF_DEPTH:
4535           {
4536             char *cp;
4537
4538             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4539           }
4540           break;
4541         case OPTION_DWARF_START:
4542           {
4543             char *cp;
4544
4545             dwarf_start_die = strtoul (optarg, & cp, 0);
4546           }
4547           break;
4548         case OPTION_DWARF_CHECK:
4549           dwarf_check = TRUE;
4550           break;
4551         case OPTION_DYN_SYMS:
4552           do_dyn_syms = TRUE;
4553           break;
4554 #ifdef SUPPORT_DISASSEMBLY
4555         case 'i':
4556           request_dump (DISASS_DUMP);
4557           break;
4558 #endif
4559         case 'v':
4560           print_version (program_name);
4561           break;
4562         case 'V':
4563           do_version = TRUE;
4564           break;
4565         case 'W':
4566           do_wide = TRUE;
4567           break;
4568         default:
4569           /* xgettext:c-format */
4570           error (_("Invalid option '-%c'\n"), c);
4571           /* Fall through.  */
4572         case '?':
4573           usage (stderr);
4574         }
4575     }
4576
4577   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4578       && !do_segments && !do_header && !do_dump && !do_version
4579       && !do_histogram && !do_debugging && !do_arch && !do_notes
4580       && !do_section_groups && !do_archive_index
4581       && !do_dyn_syms)
4582     usage (stderr);
4583 }
4584
4585 static const char *
4586 get_elf_class (unsigned int elf_class)
4587 {
4588   static char buff[32];
4589
4590   switch (elf_class)
4591     {
4592     case ELFCLASSNONE: return _("none");
4593     case ELFCLASS32:   return "ELF32";
4594     case ELFCLASS64:   return "ELF64";
4595     default:
4596       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4597       return buff;
4598     }
4599 }
4600
4601 static const char *
4602 get_data_encoding (unsigned int encoding)
4603 {
4604   static char buff[32];
4605
4606   switch (encoding)
4607     {
4608     case ELFDATANONE: return _("none");
4609     case ELFDATA2LSB: return _("2's complement, little endian");
4610     case ELFDATA2MSB: return _("2's complement, big endian");
4611     default:
4612       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4613       return buff;
4614     }
4615 }
4616
4617 /* Decode the data held in 'elf_header'.  */
4618
4619 static bfd_boolean
4620 process_file_header (void)
4621 {
4622   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4623       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4624       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4625       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4626     {
4627       error
4628         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4629       return FALSE;
4630     }
4631
4632   init_dwarf_regnames (elf_header.e_machine);
4633
4634   if (do_header)
4635     {
4636       unsigned i;
4637
4638       printf (_("ELF Header:\n"));
4639       printf (_("  Magic:   "));
4640       for (i = 0; i < EI_NIDENT; i++)
4641         printf ("%2.2x ", elf_header.e_ident[i]);
4642       printf ("\n");
4643       printf (_("  Class:                             %s\n"),
4644               get_elf_class (elf_header.e_ident[EI_CLASS]));
4645       printf (_("  Data:                              %s\n"),
4646               get_data_encoding (elf_header.e_ident[EI_DATA]));
4647       printf (_("  Version:                           %d %s\n"),
4648               elf_header.e_ident[EI_VERSION],
4649               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4650                ? "(current)"
4651                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4652                   ? _("<unknown: %lx>")
4653                   : "")));
4654       printf (_("  OS/ABI:                            %s\n"),
4655               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4656       printf (_("  ABI Version:                       %d\n"),
4657               elf_header.e_ident[EI_ABIVERSION]);
4658       printf (_("  Type:                              %s\n"),
4659               get_file_type (elf_header.e_type));
4660       printf (_("  Machine:                           %s\n"),
4661               get_machine_name (elf_header.e_machine));
4662       printf (_("  Version:                           0x%lx\n"),
4663               (unsigned long) elf_header.e_version);
4664
4665       printf (_("  Entry point address:               "));
4666       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4667       printf (_("\n  Start of program headers:          "));
4668       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4669       printf (_(" (bytes into file)\n  Start of section headers:          "));
4670       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4671       printf (_(" (bytes into file)\n"));
4672
4673       printf (_("  Flags:                             0x%lx%s\n"),
4674               (unsigned long) elf_header.e_flags,
4675               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4676       printf (_("  Size of this header:               %ld (bytes)\n"),
4677               (long) elf_header.e_ehsize);
4678       printf (_("  Size of program headers:           %ld (bytes)\n"),
4679               (long) elf_header.e_phentsize);
4680       printf (_("  Number of program headers:         %ld"),
4681               (long) elf_header.e_phnum);
4682       if (section_headers != NULL
4683           && elf_header.e_phnum == PN_XNUM
4684           && section_headers[0].sh_info != 0)
4685         printf (" (%ld)", (long) section_headers[0].sh_info);
4686       putc ('\n', stdout);
4687       printf (_("  Size of section headers:           %ld (bytes)\n"),
4688               (long) elf_header.e_shentsize);
4689       printf (_("  Number of section headers:         %ld"),
4690               (long) elf_header.e_shnum);
4691       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4692         printf (" (%ld)", (long) section_headers[0].sh_size);
4693       putc ('\n', stdout);
4694       printf (_("  Section header string table index: %ld"),
4695               (long) elf_header.e_shstrndx);
4696       if (section_headers != NULL
4697           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4698         printf (" (%u)", section_headers[0].sh_link);
4699       else if (elf_header.e_shstrndx != SHN_UNDEF
4700                && elf_header.e_shstrndx >= elf_header.e_shnum)
4701         printf (_(" <corrupt: out of range>"));
4702       putc ('\n', stdout);
4703     }
4704
4705   if (section_headers != NULL)
4706     {
4707       if (elf_header.e_phnum == PN_XNUM
4708           && section_headers[0].sh_info != 0)
4709         elf_header.e_phnum = section_headers[0].sh_info;
4710       if (elf_header.e_shnum == SHN_UNDEF)
4711         elf_header.e_shnum = section_headers[0].sh_size;
4712       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4713         elf_header.e_shstrndx = section_headers[0].sh_link;
4714       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4715         elf_header.e_shstrndx = SHN_UNDEF;
4716       free (section_headers);
4717       section_headers = NULL;
4718     }
4719
4720   return TRUE;
4721 }
4722
4723 static bfd_boolean
4724 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4725 {
4726   Elf32_External_Phdr * phdrs;
4727   Elf32_External_Phdr * external;
4728   Elf_Internal_Phdr *   internal;
4729   unsigned int i;
4730   unsigned int size = elf_header.e_phentsize;
4731   unsigned int num  = elf_header.e_phnum;
4732
4733   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4734   if (size == 0 || num == 0)
4735     return FALSE;
4736   if (size < sizeof * phdrs)
4737     {
4738       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4739       return FALSE;
4740     }
4741   if (size > sizeof * phdrs)
4742     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4743
4744   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4745                                             size, num, _("program headers"));
4746   if (phdrs == NULL)
4747     return FALSE;
4748
4749   for (i = 0, internal = pheaders, external = phdrs;
4750        i < elf_header.e_phnum;
4751        i++, internal++, external++)
4752     {
4753       internal->p_type   = BYTE_GET (external->p_type);
4754       internal->p_offset = BYTE_GET (external->p_offset);
4755       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4756       internal->p_paddr  = BYTE_GET (external->p_paddr);
4757       internal->p_filesz = BYTE_GET (external->p_filesz);
4758       internal->p_memsz  = BYTE_GET (external->p_memsz);
4759       internal->p_flags  = BYTE_GET (external->p_flags);
4760       internal->p_align  = BYTE_GET (external->p_align);
4761     }
4762
4763   free (phdrs);
4764   return TRUE;
4765 }
4766
4767 static bfd_boolean
4768 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4769 {
4770   Elf64_External_Phdr * phdrs;
4771   Elf64_External_Phdr * external;
4772   Elf_Internal_Phdr *   internal;
4773   unsigned int i;
4774   unsigned int size = elf_header.e_phentsize;
4775   unsigned int num  = elf_header.e_phnum;
4776
4777   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4778   if (size == 0 || num == 0)
4779     return FALSE;
4780   if (size < sizeof * phdrs)
4781     {
4782       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4783       return FALSE;
4784     }
4785   if (size > sizeof * phdrs)
4786     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4787
4788   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4789                                             size, num, _("program headers"));
4790   if (!phdrs)
4791     return FALSE;
4792
4793   for (i = 0, internal = pheaders, external = phdrs;
4794        i < elf_header.e_phnum;
4795        i++, internal++, external++)
4796     {
4797       internal->p_type   = BYTE_GET (external->p_type);
4798       internal->p_flags  = BYTE_GET (external->p_flags);
4799       internal->p_offset = BYTE_GET (external->p_offset);
4800       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4801       internal->p_paddr  = BYTE_GET (external->p_paddr);
4802       internal->p_filesz = BYTE_GET (external->p_filesz);
4803       internal->p_memsz  = BYTE_GET (external->p_memsz);
4804       internal->p_align  = BYTE_GET (external->p_align);
4805     }
4806
4807   free (phdrs);
4808   return TRUE;
4809 }
4810
4811 /* Returns TRUE if the program headers were read into `program_headers'.  */
4812
4813 static bfd_boolean
4814 get_program_headers (FILE * file)
4815 {
4816   Elf_Internal_Phdr * phdrs;
4817
4818   /* Check cache of prior read.  */
4819   if (program_headers != NULL)
4820     return TRUE;
4821
4822   /* Be kind to memory checkers by looking for
4823      e_phnum values which we know must be invalid.  */
4824   if (elf_header.e_phnum
4825       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4826       >= current_file_size)
4827     {
4828       error (_("Too many program headers - %#x - the file is not that big\n"),
4829              elf_header.e_phnum);
4830       return FALSE;
4831     }
4832
4833   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4834                                          sizeof (Elf_Internal_Phdr));
4835   if (phdrs == NULL)
4836     {
4837       error (_("Out of memory reading %u program headers\n"),
4838              elf_header.e_phnum);
4839       return FALSE;
4840     }
4841
4842   if (is_32bit_elf
4843       ? get_32bit_program_headers (file, phdrs)
4844       : get_64bit_program_headers (file, phdrs))
4845     {
4846       program_headers = phdrs;
4847       return TRUE;
4848     }
4849
4850   free (phdrs);
4851   return FALSE;
4852 }
4853
4854 /* Returns TRUE if the program headers were loaded.  */
4855
4856 static bfd_boolean
4857 process_program_headers (FILE * file)
4858 {
4859   Elf_Internal_Phdr * segment;
4860   unsigned int i;
4861   Elf_Internal_Phdr * previous_load = NULL;
4862
4863   if (elf_header.e_phnum == 0)
4864     {
4865       /* PR binutils/12467.  */
4866       if (elf_header.e_phoff != 0)
4867         {
4868           warn (_("possibly corrupt ELF header - it has a non-zero program"
4869                   " header offset, but no program headers\n"));
4870           return FALSE;
4871         }
4872       else if (do_segments)
4873         printf (_("\nThere are no program headers in this file.\n"));
4874       return TRUE;
4875     }
4876
4877   if (do_segments && !do_header)
4878     {
4879       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4880       printf (_("Entry point "));
4881       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4882       printf (_("\nThere are %d program headers, starting at offset "),
4883               elf_header.e_phnum);
4884       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4885       printf ("\n");
4886     }
4887
4888   if (! get_program_headers (file))
4889     return TRUE;
4890
4891   if (do_segments)
4892     {
4893       if (elf_header.e_phnum > 1)
4894         printf (_("\nProgram Headers:\n"));
4895       else
4896         printf (_("\nProgram Headers:\n"));
4897
4898       if (is_32bit_elf)
4899         printf
4900           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4901       else if (do_wide)
4902         printf
4903           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4904       else
4905         {
4906           printf
4907             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4908           printf
4909             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4910         }
4911     }
4912
4913   dynamic_addr = 0;
4914   dynamic_size = 0;
4915
4916   for (i = 0, segment = program_headers;
4917        i < elf_header.e_phnum;
4918        i++, segment++)
4919     {
4920       if (do_segments)
4921         {
4922           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4923
4924           if (is_32bit_elf)
4925             {
4926               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4927               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4928               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4929               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4930               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4931               printf ("%c%c%c ",
4932                       (segment->p_flags & PF_R ? 'R' : ' '),
4933                       (segment->p_flags & PF_W ? 'W' : ' '),
4934                       (segment->p_flags & PF_X ? 'E' : ' '));
4935               printf ("%#lx", (unsigned long) segment->p_align);
4936             }
4937           else if (do_wide)
4938             {
4939               if ((unsigned long) segment->p_offset == segment->p_offset)
4940                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4941               else
4942                 {
4943                   print_vma (segment->p_offset, FULL_HEX);
4944                   putchar (' ');
4945                 }
4946
4947               print_vma (segment->p_vaddr, FULL_HEX);
4948               putchar (' ');
4949               print_vma (segment->p_paddr, FULL_HEX);
4950               putchar (' ');
4951
4952               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4953                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4954               else
4955                 {
4956                   print_vma (segment->p_filesz, FULL_HEX);
4957                   putchar (' ');
4958                 }
4959
4960               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4961                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4962               else
4963                 {
4964                   print_vma (segment->p_memsz, FULL_HEX);
4965                 }
4966
4967               printf (" %c%c%c ",
4968                       (segment->p_flags & PF_R ? 'R' : ' '),
4969                       (segment->p_flags & PF_W ? 'W' : ' '),
4970                       (segment->p_flags & PF_X ? 'E' : ' '));
4971
4972               if ((unsigned long) segment->p_align == segment->p_align)
4973                 printf ("%#lx", (unsigned long) segment->p_align);
4974               else
4975                 {
4976                   print_vma (segment->p_align, PREFIX_HEX);
4977                 }
4978             }
4979           else
4980             {
4981               print_vma (segment->p_offset, FULL_HEX);
4982               putchar (' ');
4983               print_vma (segment->p_vaddr, FULL_HEX);
4984               putchar (' ');
4985               print_vma (segment->p_paddr, FULL_HEX);
4986               printf ("\n                 ");
4987               print_vma (segment->p_filesz, FULL_HEX);
4988               putchar (' ');
4989               print_vma (segment->p_memsz, FULL_HEX);
4990               printf ("  %c%c%c    ",
4991                       (segment->p_flags & PF_R ? 'R' : ' '),
4992                       (segment->p_flags & PF_W ? 'W' : ' '),
4993                       (segment->p_flags & PF_X ? 'E' : ' '));
4994               print_vma (segment->p_align, PREFIX_HEX);
4995             }
4996
4997           putc ('\n', stdout);
4998         }
4999
5000       switch (segment->p_type)
5001         {
5002         case PT_LOAD:
5003 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5004          required by the ELF standard, several programs, including the Linux
5005          kernel, make use of non-ordered segments.  */
5006           if (previous_load
5007               && previous_load->p_vaddr > segment->p_vaddr)
5008             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5009 #endif
5010           if (segment->p_memsz < segment->p_filesz)
5011             error (_("the segment's file size is larger than its memory size\n"));
5012           previous_load = segment;
5013           break;
5014
5015         case PT_PHDR:
5016           /* PR 20815 - Verify that the program header is loaded into memory.  */
5017           if (i > 0 && previous_load != NULL)
5018             error (_("the PHDR segment must occur before any LOAD segment\n"));
5019           if (elf_header.e_machine != EM_PARISC)
5020             {
5021               unsigned int j;
5022
5023               for (j = 1; j < elf_header.e_phnum; j++)
5024                 if (program_headers[j].p_vaddr <= segment->p_vaddr
5025                     && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5026                     >= (segment->p_vaddr + segment->p_filesz))
5027                   break;
5028               if (j == elf_header.e_phnum)
5029                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5030             }
5031           break;
5032
5033         case PT_DYNAMIC:
5034           if (dynamic_addr)
5035             error (_("more than one dynamic segment\n"));
5036
5037           /* By default, assume that the .dynamic section is the first
5038              section in the DYNAMIC segment.  */
5039           dynamic_addr = segment->p_offset;
5040           dynamic_size = segment->p_filesz;
5041
5042           /* Try to locate the .dynamic section. If there is
5043              a section header table, we can easily locate it.  */
5044           if (section_headers != NULL)
5045             {
5046               Elf_Internal_Shdr * sec;
5047
5048               sec = find_section (".dynamic");
5049               if (sec == NULL || sec->sh_size == 0)
5050                 {
5051                   /* A corresponding .dynamic section is expected, but on
5052                      IA-64/OpenVMS it is OK for it to be missing.  */
5053                   if (!is_ia64_vms ())
5054                     error (_("no .dynamic section in the dynamic segment\n"));
5055                   break;
5056                 }
5057
5058               if (sec->sh_type == SHT_NOBITS)
5059                 {
5060                   dynamic_size = 0;
5061                   break;
5062                 }
5063
5064               dynamic_addr = sec->sh_offset;
5065               dynamic_size = sec->sh_size;
5066
5067               if (dynamic_addr < segment->p_offset
5068                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5069                 warn (_("the .dynamic section is not contained"
5070                         " within the dynamic segment\n"));
5071               else if (dynamic_addr > segment->p_offset)
5072                 warn (_("the .dynamic section is not the first section"
5073                         " in the dynamic segment.\n"));
5074             }
5075
5076           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5077              segment.  Check this after matching against the section headers
5078              so we don't warn on debuginfo file (which have NOBITS .dynamic
5079              sections).  */
5080           if (dynamic_addr + dynamic_size >= current_file_size)
5081             {
5082               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5083               dynamic_addr = dynamic_size = 0;
5084             }
5085           break;
5086
5087         case PT_INTERP:
5088           if (fseek (file, archive_file_offset + (long) segment->p_offset,
5089                      SEEK_SET))
5090             error (_("Unable to find program interpreter name\n"));
5091           else
5092             {
5093               char fmt [32];
5094               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5095
5096               if (ret >= (int) sizeof (fmt) || ret < 0)
5097                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5098
5099               program_interpreter[0] = 0;
5100               if (fscanf (file, fmt, program_interpreter) <= 0)
5101                 error (_("Unable to read program interpreter name\n"));
5102
5103               if (do_segments)
5104                 printf (_("      [Requesting program interpreter: %s]\n"),
5105                     program_interpreter);
5106             }
5107           break;
5108         }
5109     }
5110
5111   if (do_segments && section_headers != NULL && string_table != NULL)
5112     {
5113       printf (_("\n Section to Segment mapping:\n"));
5114       printf (_("  Segment Sections...\n"));
5115
5116       for (i = 0; i < elf_header.e_phnum; i++)
5117         {
5118           unsigned int j;
5119           Elf_Internal_Shdr * section;
5120
5121           segment = program_headers + i;
5122           section = section_headers + 1;
5123
5124           printf ("   %2.2d     ", i);
5125
5126           for (j = 1; j < elf_header.e_shnum; j++, section++)
5127             {
5128               if (!ELF_TBSS_SPECIAL (section, segment)
5129                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5130                 printf ("%s ", printable_section_name (section));
5131             }
5132
5133           putc ('\n',stdout);
5134         }
5135     }
5136
5137   return TRUE;
5138 }
5139
5140
5141 /* Find the file offset corresponding to VMA by using the program headers.  */
5142
5143 static long
5144 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5145 {
5146   Elf_Internal_Phdr * seg;
5147
5148   if (! get_program_headers (file))
5149     {
5150       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5151       return (long) vma;
5152     }
5153
5154   for (seg = program_headers;
5155        seg < program_headers + elf_header.e_phnum;
5156        ++seg)
5157     {
5158       if (seg->p_type != PT_LOAD)
5159         continue;
5160
5161       if (vma >= (seg->p_vaddr & -seg->p_align)
5162           && vma + size <= seg->p_vaddr + seg->p_filesz)
5163         return vma - seg->p_vaddr + seg->p_offset;
5164     }
5165
5166   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5167         (unsigned long) vma);
5168   return (long) vma;
5169 }
5170
5171
5172 /* Allocate memory and load the sections headers into the global pointer
5173    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
5174    generate any error messages if the load fails.  */
5175
5176 static bfd_boolean
5177 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5178 {
5179   Elf32_External_Shdr * shdrs;
5180   Elf_Internal_Shdr *   internal;
5181   unsigned int i;
5182   unsigned int size = elf_header.e_shentsize;
5183   unsigned int num = probe ? 1 : elf_header.e_shnum;
5184
5185   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5186   if (size == 0 || num == 0)
5187     return FALSE;
5188   if (size < sizeof * shdrs)
5189     {
5190       if (! probe)
5191         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5192       return FALSE;
5193     }
5194   if (!probe && size > sizeof * shdrs)
5195     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5196
5197   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5198                                             size, num,
5199                                             probe ? NULL : _("section headers"));
5200   if (shdrs == NULL)
5201     return FALSE;
5202
5203   if (section_headers != NULL)
5204     free (section_headers);
5205   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5206                                                    sizeof (Elf_Internal_Shdr));
5207   if (section_headers == NULL)
5208     {
5209       if (!probe)
5210         error (_("Out of memory reading %u section headers\n"), num);
5211       return FALSE;
5212     }
5213
5214   for (i = 0, internal = section_headers;
5215        i < num;
5216        i++, internal++)
5217     {
5218       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5219       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5220       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5221       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5222       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5223       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5224       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5225       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5226       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5227       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5228       if (!probe && internal->sh_link > num)
5229         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5230       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5231         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5232     }
5233
5234   free (shdrs);
5235   return TRUE;
5236 }
5237
5238 static bfd_boolean
5239 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5240 {
5241   Elf64_External_Shdr * shdrs;
5242   Elf_Internal_Shdr *   internal;
5243   unsigned int i;
5244   unsigned int size = elf_header.e_shentsize;
5245   unsigned int num = probe ? 1 : elf_header.e_shnum;
5246
5247   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5248   if (size == 0 || num == 0)
5249     return FALSE;
5250   if (size < sizeof * shdrs)
5251     {
5252       if (! probe)
5253         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5254       return FALSE;
5255     }
5256   if (! probe && size > sizeof * shdrs)
5257     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5258
5259   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5260                                             size, num,
5261                                             probe ? NULL : _("section headers"));
5262   if (shdrs == NULL)
5263     return FALSE;
5264
5265   if (section_headers != NULL)
5266     free (section_headers);
5267   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5268                                                    sizeof (Elf_Internal_Shdr));
5269   if (section_headers == NULL)
5270     {
5271       if (! probe)
5272         error (_("Out of memory reading %u section headers\n"), num);
5273       return FALSE;
5274     }
5275
5276   for (i = 0, internal = section_headers;
5277        i < num;
5278        i++, internal++)
5279     {
5280       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5281       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5282       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5283       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5284       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5285       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5286       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5287       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5288       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5289       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5290       if (!probe && internal->sh_link > num)
5291         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5292       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5293         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5294     }
5295
5296   free (shdrs);
5297   return TRUE;
5298 }
5299
5300 static Elf_Internal_Sym *
5301 get_32bit_elf_symbols (FILE * file,
5302                        Elf_Internal_Shdr * section,
5303                        unsigned long * num_syms_return)
5304 {
5305   unsigned long number = 0;
5306   Elf32_External_Sym * esyms = NULL;
5307   Elf_External_Sym_Shndx * shndx = NULL;
5308   Elf_Internal_Sym * isyms = NULL;
5309   Elf_Internal_Sym * psym;
5310   unsigned int j;
5311
5312   if (section->sh_size == 0)
5313     {
5314       if (num_syms_return != NULL)
5315         * num_syms_return = 0;
5316       return NULL;
5317     }
5318
5319   /* Run some sanity checks first.  */
5320   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5321     {
5322       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5323              printable_section_name (section), (unsigned long) section->sh_entsize);
5324       goto exit_point;
5325     }
5326
5327   if (section->sh_size > current_file_size)
5328     {
5329       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5330              printable_section_name (section), (unsigned long) section->sh_size);
5331       goto exit_point;
5332     }
5333
5334   number = section->sh_size / section->sh_entsize;
5335
5336   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5337     {
5338       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5339              (unsigned long) section->sh_size,
5340              printable_section_name (section),
5341              (unsigned long) section->sh_entsize);
5342       goto exit_point;
5343     }
5344
5345   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5346                                            section->sh_size, _("symbols"));
5347   if (esyms == NULL)
5348     goto exit_point;
5349
5350   {
5351     elf_section_list * entry;
5352
5353     shndx = NULL;
5354     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5355       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5356         {
5357           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5358                                                        entry->hdr->sh_offset,
5359                                                        1, entry->hdr->sh_size,
5360                                                        _("symbol table section indicies"));
5361           if (shndx == NULL)
5362             goto exit_point;
5363           /* PR17531: file: heap-buffer-overflow */
5364           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5365             {
5366               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5367                      printable_section_name (entry->hdr),
5368                      (unsigned long) entry->hdr->sh_size,
5369                      (unsigned long) section->sh_size);
5370               goto exit_point;
5371             }
5372         }
5373   }
5374
5375   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5376
5377   if (isyms == NULL)
5378     {
5379       error (_("Out of memory reading %lu symbols\n"),
5380              (unsigned long) number);
5381       goto exit_point;
5382     }
5383
5384   for (j = 0, psym = isyms; j < number; j++, psym++)
5385     {
5386       psym->st_name  = BYTE_GET (esyms[j].st_name);
5387       psym->st_value = BYTE_GET (esyms[j].st_value);
5388       psym->st_size  = BYTE_GET (esyms[j].st_size);
5389       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5390       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5391         psym->st_shndx
5392           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5393       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5394         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5395       psym->st_info  = BYTE_GET (esyms[j].st_info);
5396       psym->st_other = BYTE_GET (esyms[j].st_other);
5397     }
5398
5399  exit_point:
5400   if (shndx != NULL)
5401     free (shndx);
5402   if (esyms != NULL)
5403     free (esyms);
5404
5405   if (num_syms_return != NULL)
5406     * num_syms_return = isyms == NULL ? 0 : number;
5407
5408   return isyms;
5409 }
5410
5411 static Elf_Internal_Sym *
5412 get_64bit_elf_symbols (FILE * file,
5413                        Elf_Internal_Shdr * section,
5414                        unsigned long * num_syms_return)
5415 {
5416   unsigned long number = 0;
5417   Elf64_External_Sym * esyms = NULL;
5418   Elf_External_Sym_Shndx * shndx = NULL;
5419   Elf_Internal_Sym * isyms = NULL;
5420   Elf_Internal_Sym * psym;
5421   unsigned int j;
5422
5423   if (section->sh_size == 0)
5424     {
5425       if (num_syms_return != NULL)
5426         * num_syms_return = 0;
5427       return NULL;
5428     }
5429
5430   /* Run some sanity checks first.  */
5431   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5432     {
5433       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5434              printable_section_name (section),
5435              (unsigned long) section->sh_entsize);
5436       goto exit_point;
5437     }
5438
5439   if (section->sh_size > current_file_size)
5440     {
5441       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5442              printable_section_name (section),
5443              (unsigned long) section->sh_size);
5444       goto exit_point;
5445     }
5446
5447   number = section->sh_size / section->sh_entsize;
5448
5449   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5450     {
5451       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5452              (unsigned long) section->sh_size,
5453              printable_section_name (section),
5454              (unsigned long) section->sh_entsize);
5455       goto exit_point;
5456     }
5457
5458   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5459                                            section->sh_size, _("symbols"));
5460   if (!esyms)
5461     goto exit_point;
5462
5463   {
5464     elf_section_list * entry;
5465
5466     shndx = NULL;
5467     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5468       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5469         {
5470           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5471                                                        entry->hdr->sh_offset,
5472                                                        1, entry->hdr->sh_size,
5473                                                        _("symbol table section indicies"));
5474           if (shndx == NULL)
5475             goto exit_point;
5476           /* PR17531: file: heap-buffer-overflow */
5477           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5478             {
5479               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5480                      printable_section_name (entry->hdr),
5481                      (unsigned long) entry->hdr->sh_size,
5482                      (unsigned long) section->sh_size);
5483               goto exit_point;
5484             }
5485         }
5486   }
5487
5488   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5489
5490   if (isyms == NULL)
5491     {
5492       error (_("Out of memory reading %lu symbols\n"),
5493              (unsigned long) number);
5494       goto exit_point;
5495     }
5496
5497   for (j = 0, psym = isyms; j < number; j++, psym++)
5498     {
5499       psym->st_name  = BYTE_GET (esyms[j].st_name);
5500       psym->st_info  = BYTE_GET (esyms[j].st_info);
5501       psym->st_other = BYTE_GET (esyms[j].st_other);
5502       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5503
5504       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5505         psym->st_shndx
5506           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5507       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5508         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5509
5510       psym->st_value = BYTE_GET (esyms[j].st_value);
5511       psym->st_size  = BYTE_GET (esyms[j].st_size);
5512     }
5513
5514  exit_point:
5515   if (shndx != NULL)
5516     free (shndx);
5517   if (esyms != NULL)
5518     free (esyms);
5519
5520   if (num_syms_return != NULL)
5521     * num_syms_return = isyms == NULL ? 0 : number;
5522
5523   return isyms;
5524 }
5525
5526 static const char *
5527 get_elf_section_flags (bfd_vma sh_flags)
5528 {
5529   static char buff[1024];
5530   char * p = buff;
5531   unsigned int field_size = is_32bit_elf ? 8 : 16;
5532   signed int sindex;
5533   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5534   bfd_vma os_flags = 0;
5535   bfd_vma proc_flags = 0;
5536   bfd_vma unknown_flags = 0;
5537   static const struct
5538     {
5539       const char * str;
5540       unsigned int len;
5541     }
5542   flags [] =
5543     {
5544       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5545       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5546       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5547       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5548       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5549       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5550       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5551       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5552       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5553       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5554       /* IA-64 specific.  */
5555       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5556       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5557       /* IA-64 OpenVMS specific.  */
5558       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5559       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5560       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5561       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5562       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5563       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5564       /* Generic.  */
5565       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5566       /* SPARC specific.  */
5567       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5568       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5569       /* ARM specific.  */
5570       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5571       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5572       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5573       /* GNU specific.  */
5574       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5575     };
5576
5577   if (do_section_details)
5578     {
5579       sprintf (buff, "[%*.*lx]: ",
5580                field_size, field_size, (unsigned long) sh_flags);
5581       p += field_size + 4;
5582     }
5583
5584   while (sh_flags)
5585     {
5586       bfd_vma flag;
5587
5588       flag = sh_flags & - sh_flags;
5589       sh_flags &= ~ flag;
5590
5591       if (do_section_details)
5592         {
5593           switch (flag)
5594             {
5595             case SHF_WRITE:             sindex = 0; break;
5596             case SHF_ALLOC:             sindex = 1; break;
5597             case SHF_EXECINSTR:         sindex = 2; break;
5598             case SHF_MERGE:             sindex = 3; break;
5599             case SHF_STRINGS:           sindex = 4; break;
5600             case SHF_INFO_LINK:         sindex = 5; break;
5601             case SHF_LINK_ORDER:        sindex = 6; break;
5602             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5603             case SHF_GROUP:             sindex = 8; break;
5604             case SHF_TLS:               sindex = 9; break;
5605             case SHF_EXCLUDE:           sindex = 18; break;
5606             case SHF_COMPRESSED:        sindex = 20; break;
5607             case SHF_GNU_MBIND:         sindex = 24; break;
5608
5609             default:
5610               sindex = -1;
5611               switch (elf_header.e_machine)
5612                 {
5613                 case EM_IA_64:
5614                   if (flag == SHF_IA_64_SHORT)
5615                     sindex = 10;
5616                   else if (flag == SHF_IA_64_NORECOV)
5617                     sindex = 11;
5618 #ifdef BFD64
5619                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5620                     switch (flag)
5621                       {
5622                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5623                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5624                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5625                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5626                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5627                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5628                       default:                        break;
5629                       }
5630 #endif
5631                   break;
5632
5633                 case EM_386:
5634                 case EM_IAMCU:
5635                 case EM_X86_64:
5636                 case EM_L1OM:
5637                 case EM_K1OM:
5638                 case EM_OLD_SPARCV9:
5639                 case EM_SPARC32PLUS:
5640                 case EM_SPARCV9:
5641                 case EM_SPARC:
5642                   if (flag == SHF_ORDERED)
5643                     sindex = 19;
5644                   break;
5645
5646                 case EM_ARM:
5647                   switch (flag)
5648                     {
5649                     case SHF_ENTRYSECT: sindex = 21; break;
5650                     case SHF_ARM_PURECODE: sindex = 22; break;
5651                     case SHF_COMDEF: sindex = 23; break;
5652                     default: break;
5653                     }
5654                   break;
5655
5656                 default:
5657                   break;
5658                 }
5659             }
5660
5661           if (sindex != -1)
5662             {
5663               if (p != buff + field_size + 4)
5664                 {
5665                   if (size < (10 + 2))
5666                     {
5667                       warn (_("Internal error: not enough buffer room for section flag info"));
5668                       return _("<unknown>");
5669                     }
5670                   size -= 2;
5671                   *p++ = ',';
5672                   *p++ = ' ';
5673                 }
5674
5675               size -= flags [sindex].len;
5676               p = stpcpy (p, flags [sindex].str);
5677             }
5678           else if (flag & SHF_MASKOS)
5679             os_flags |= flag;
5680           else if (flag & SHF_MASKPROC)
5681             proc_flags |= flag;
5682           else
5683             unknown_flags |= flag;
5684         }
5685       else
5686         {
5687           switch (flag)
5688             {
5689             case SHF_WRITE:             *p = 'W'; break;
5690             case SHF_ALLOC:             *p = 'A'; break;
5691             case SHF_EXECINSTR:         *p = 'X'; break;
5692             case SHF_MERGE:             *p = 'M'; break;
5693             case SHF_STRINGS:           *p = 'S'; break;
5694             case SHF_INFO_LINK:         *p = 'I'; break;
5695             case SHF_LINK_ORDER:        *p = 'L'; break;
5696             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5697             case SHF_GROUP:             *p = 'G'; break;
5698             case SHF_TLS:               *p = 'T'; break;
5699             case SHF_EXCLUDE:           *p = 'E'; break;
5700             case SHF_COMPRESSED:        *p = 'C'; break;
5701             case SHF_GNU_MBIND:         *p = 'D'; break;
5702
5703             default:
5704               if ((elf_header.e_machine == EM_X86_64
5705                    || elf_header.e_machine == EM_L1OM
5706                    || elf_header.e_machine == EM_K1OM)
5707                   && flag == SHF_X86_64_LARGE)
5708                 *p = 'l';
5709               else if (elf_header.e_machine == EM_ARM
5710                        && flag == SHF_ARM_PURECODE)
5711                   *p = 'y';
5712               else if (flag & SHF_MASKOS)
5713                 {
5714                   *p = 'o';
5715                   sh_flags &= ~ SHF_MASKOS;
5716                 }
5717               else if (flag & SHF_MASKPROC)
5718                 {
5719                   *p = 'p';
5720                   sh_flags &= ~ SHF_MASKPROC;
5721                 }
5722               else
5723                 *p = 'x';
5724               break;
5725             }
5726           p++;
5727         }
5728     }
5729
5730   if (do_section_details)
5731     {
5732       if (os_flags)
5733         {
5734           size -= 5 + field_size;
5735           if (p != buff + field_size + 4)
5736             {
5737               if (size < (2 + 1))
5738                 {
5739                   warn (_("Internal error: not enough buffer room for section flag info"));
5740                   return _("<unknown>");
5741                 }
5742               size -= 2;
5743               *p++ = ',';
5744               *p++ = ' ';
5745             }
5746           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5747                    (unsigned long) os_flags);
5748           p += 5 + field_size;
5749         }
5750       if (proc_flags)
5751         {
5752           size -= 7 + field_size;
5753           if (p != buff + field_size + 4)
5754             {
5755               if (size < (2 + 1))
5756                 {
5757                   warn (_("Internal error: not enough buffer room for section flag info"));
5758                   return _("<unknown>");
5759                 }
5760               size -= 2;
5761               *p++ = ',';
5762               *p++ = ' ';
5763             }
5764           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5765                    (unsigned long) proc_flags);
5766           p += 7 + field_size;
5767         }
5768       if (unknown_flags)
5769         {
5770           size -= 10 + field_size;
5771           if (p != buff + field_size + 4)
5772             {
5773               if (size < (2 + 1))
5774                 {
5775                   warn (_("Internal error: not enough buffer room for section flag info"));
5776                   return _("<unknown>");
5777                 }
5778               size -= 2;
5779               *p++ = ',';
5780               *p++ = ' ';
5781             }
5782           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5783                    (unsigned long) unknown_flags);
5784           p += 10 + field_size;
5785         }
5786     }
5787
5788   *p = '\0';
5789   return buff;
5790 }
5791
5792 static unsigned int
5793 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5794 {
5795   if (is_32bit_elf)
5796     {
5797       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5798
5799       if (size < sizeof (* echdr))
5800         {
5801           error (_("Compressed section is too small even for a compression header\n"));
5802           return 0;
5803         }
5804
5805       chdr->ch_type = BYTE_GET (echdr->ch_type);
5806       chdr->ch_size = BYTE_GET (echdr->ch_size);
5807       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5808       return sizeof (*echdr);
5809     }
5810   else
5811     {
5812       Elf64_External_Chdr *echdr = (Elf64_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 }
5826
5827 static bfd_boolean
5828 process_section_headers (FILE * file)
5829 {
5830   Elf_Internal_Shdr * section;
5831   unsigned int i;
5832
5833   section_headers = NULL;
5834
5835   if (elf_header.e_shnum == 0)
5836     {
5837       /* PR binutils/12467.  */
5838       if (elf_header.e_shoff != 0)
5839         {
5840           warn (_("possibly corrupt ELF file header - it has a non-zero"
5841                   " section header offset, but no section headers\n"));
5842           return FALSE;
5843         }
5844       else if (do_sections)
5845         printf (_("\nThere are no sections in this file.\n"));
5846
5847       return TRUE;
5848     }
5849
5850   if (do_sections && !do_header)
5851     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5852             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5853
5854   if (is_32bit_elf)
5855     {
5856       if (! get_32bit_section_headers (file, FALSE))
5857         return FALSE;
5858     }
5859   else
5860     {
5861       if (! get_64bit_section_headers (file, FALSE))
5862         return FALSE;
5863     }
5864
5865   /* Read in the string table, so that we have names to display.  */
5866   if (elf_header.e_shstrndx != SHN_UNDEF
5867        && elf_header.e_shstrndx < elf_header.e_shnum)
5868     {
5869       section = section_headers + elf_header.e_shstrndx;
5870
5871       if (section->sh_size != 0)
5872         {
5873           string_table = (char *) get_data (NULL, file, section->sh_offset,
5874                                             1, section->sh_size,
5875                                             _("string table"));
5876
5877           string_table_length = string_table != NULL ? section->sh_size : 0;
5878         }
5879     }
5880
5881   /* Scan the sections for the dynamic symbol table
5882      and dynamic string table and debug sections.  */
5883   dynamic_symbols = NULL;
5884   dynamic_strings = NULL;
5885   dynamic_syminfo = NULL;
5886   symtab_shndx_list = NULL;
5887
5888   eh_addr_size = is_32bit_elf ? 4 : 8;
5889   switch (elf_header.e_machine)
5890     {
5891     case EM_MIPS:
5892     case EM_MIPS_RS3_LE:
5893       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5894          FDE addresses.  However, the ABI also has a semi-official ILP32
5895          variant for which the normal FDE address size rules apply.
5896
5897          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5898          section, where XX is the size of longs in bits.  Unfortunately,
5899          earlier compilers provided no way of distinguishing ILP32 objects
5900          from LP64 objects, so if there's any doubt, we should assume that
5901          the official LP64 form is being used.  */
5902       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5903           && find_section (".gcc_compiled_long32") == NULL)
5904         eh_addr_size = 8;
5905       break;
5906
5907     case EM_H8_300:
5908     case EM_H8_300H:
5909       switch (elf_header.e_flags & EF_H8_MACH)
5910         {
5911         case E_H8_MACH_H8300:
5912         case E_H8_MACH_H8300HN:
5913         case E_H8_MACH_H8300SN:
5914         case E_H8_MACH_H8300SXN:
5915           eh_addr_size = 2;
5916           break;
5917         case E_H8_MACH_H8300H:
5918         case E_H8_MACH_H8300S:
5919         case E_H8_MACH_H8300SX:
5920           eh_addr_size = 4;
5921           break;
5922         }
5923       break;
5924
5925     case EM_M32C_OLD:
5926     case EM_M32C:
5927       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5928         {
5929         case EF_M32C_CPU_M16C:
5930           eh_addr_size = 2;
5931           break;
5932         }
5933       break;
5934     }
5935
5936 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5937   do                                                                    \
5938     {                                                                   \
5939       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5940       if (section->sh_entsize != expected_entsize)                      \
5941         {                                                               \
5942           char buf[40];                                                 \
5943           sprintf_vma (buf, section->sh_entsize);                       \
5944           /* Note: coded this way so that there is a single string for  \
5945              translation.  */ \
5946           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5947           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5948                    (unsigned) expected_entsize);                        \
5949           section->sh_entsize = expected_entsize;                       \
5950         }                                                               \
5951     }                                                                   \
5952   while (0)
5953
5954 #define CHECK_ENTSIZE(section, i, type)                                 \
5955   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5956                         sizeof (Elf64_External_##type))
5957
5958   for (i = 0, section = section_headers;
5959        i < elf_header.e_shnum;
5960        i++, section++)
5961     {
5962       char * name = SECTION_NAME (section);
5963
5964       if (section->sh_type == SHT_DYNSYM)
5965         {
5966           if (dynamic_symbols != NULL)
5967             {
5968               error (_("File contains multiple dynamic symbol tables\n"));
5969               continue;
5970             }
5971
5972           CHECK_ENTSIZE (section, i, Sym);
5973           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5974         }
5975       else if (section->sh_type == SHT_STRTAB
5976                && streq (name, ".dynstr"))
5977         {
5978           if (dynamic_strings != NULL)
5979             {
5980               error (_("File contains multiple dynamic string tables\n"));
5981               continue;
5982             }
5983
5984           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5985                                                1, section->sh_size,
5986                                                _("dynamic strings"));
5987           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5988         }
5989       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5990         {
5991           elf_section_list * entry = xmalloc (sizeof * entry);
5992           entry->hdr = section;
5993           entry->next = symtab_shndx_list;
5994           symtab_shndx_list = entry;
5995         }
5996       else if (section->sh_type == SHT_SYMTAB)
5997         CHECK_ENTSIZE (section, i, Sym);
5998       else if (section->sh_type == SHT_GROUP)
5999         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6000       else if (section->sh_type == SHT_REL)
6001         CHECK_ENTSIZE (section, i, Rel);
6002       else if (section->sh_type == SHT_RELA)
6003         CHECK_ENTSIZE (section, i, Rela);
6004       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6005                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6006                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6007                 || do_debug_str || do_debug_loc || do_debug_ranges
6008                 || do_debug_addr || do_debug_cu_index)
6009                && (const_strneq (name, ".debug_")
6010                    || const_strneq (name, ".zdebug_")))
6011         {
6012           if (name[1] == 'z')
6013             name += sizeof (".zdebug_") - 1;
6014           else
6015             name += sizeof (".debug_") - 1;
6016
6017           if (do_debugging
6018               || (do_debug_info     && const_strneq (name, "info"))
6019               || (do_debug_info     && const_strneq (name, "types"))
6020               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6021               || (do_debug_lines    && strcmp (name, "line") == 0)
6022               || (do_debug_lines    && const_strneq (name, "line."))
6023               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6024               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6025               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6026               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6027               || (do_debug_aranges  && const_strneq (name, "aranges"))
6028               || (do_debug_ranges   && const_strneq (name, "ranges"))
6029               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6030               || (do_debug_frames   && const_strneq (name, "frame"))
6031               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6032               || (do_debug_macinfo  && const_strneq (name, "macro"))
6033               || (do_debug_str      && const_strneq (name, "str"))
6034               || (do_debug_loc      && const_strneq (name, "loc"))
6035               || (do_debug_loc      && const_strneq (name, "loclists"))
6036               || (do_debug_addr     && const_strneq (name, "addr"))
6037               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6038               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6039               )
6040             request_dump_bynumber (i, DEBUG_DUMP);
6041         }
6042       /* Linkonce section to be combined with .debug_info at link time.  */
6043       else if ((do_debugging || do_debug_info)
6044                && const_strneq (name, ".gnu.linkonce.wi."))
6045         request_dump_bynumber (i, DEBUG_DUMP);
6046       else if (do_debug_frames && streq (name, ".eh_frame"))
6047         request_dump_bynumber (i, DEBUG_DUMP);
6048       else if (do_gdb_index && streq (name, ".gdb_index"))
6049         request_dump_bynumber (i, DEBUG_DUMP);
6050       /* Trace sections for Itanium VMS.  */
6051       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6052                 || do_trace_aranges)
6053                && const_strneq (name, ".trace_"))
6054         {
6055           name += sizeof (".trace_") - 1;
6056
6057           if (do_debugging
6058               || (do_trace_info     && streq (name, "info"))
6059               || (do_trace_abbrevs  && streq (name, "abbrev"))
6060               || (do_trace_aranges  && streq (name, "aranges"))
6061               )
6062             request_dump_bynumber (i, DEBUG_DUMP);
6063         }
6064     }
6065
6066   if (! do_sections)
6067     return TRUE;
6068
6069   if (elf_header.e_shnum > 1)
6070     printf (_("\nSection Headers:\n"));
6071   else
6072     printf (_("\nSection Header:\n"));
6073
6074   if (is_32bit_elf)
6075     {
6076       if (do_section_details)
6077         {
6078           printf (_("  [Nr] Name\n"));
6079           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6080         }
6081       else
6082         printf
6083           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6084     }
6085   else if (do_wide)
6086     {
6087       if (do_section_details)
6088         {
6089           printf (_("  [Nr] Name\n"));
6090           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6091         }
6092       else
6093         printf
6094           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6095     }
6096   else
6097     {
6098       if (do_section_details)
6099         {
6100           printf (_("  [Nr] Name\n"));
6101           printf (_("       Type              Address          Offset            Link\n"));
6102           printf (_("       Size              EntSize          Info              Align\n"));
6103         }
6104       else
6105         {
6106           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6107           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6108         }
6109     }
6110
6111   if (do_section_details)
6112     printf (_("       Flags\n"));
6113
6114   for (i = 0, section = section_headers;
6115        i < elf_header.e_shnum;
6116        i++, section++)
6117     {
6118       /* Run some sanity checks on the section header.  */
6119
6120       /* Check the sh_link field.  */
6121       switch (section->sh_type)
6122         {
6123         case SHT_SYMTAB_SHNDX:
6124         case SHT_GROUP:
6125         case SHT_HASH:
6126         case SHT_GNU_HASH:
6127         case SHT_GNU_versym:
6128         case SHT_REL:
6129         case SHT_RELA:
6130           if (section->sh_link < 1
6131               || section->sh_link >= elf_header.e_shnum
6132               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6133                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6134             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6135                   i, section->sh_link);
6136           break;
6137
6138         case SHT_DYNAMIC:
6139         case SHT_SYMTAB:
6140         case SHT_DYNSYM:
6141         case SHT_GNU_verneed:
6142         case SHT_GNU_verdef:
6143         case SHT_GNU_LIBLIST:
6144           if (section->sh_link < 1
6145               || section->sh_link >= elf_header.e_shnum
6146               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6147             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6148                   i, section->sh_link);
6149           break;
6150
6151         case SHT_INIT_ARRAY:
6152         case SHT_FINI_ARRAY:
6153         case SHT_PREINIT_ARRAY:
6154           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6155             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6156                   i, section->sh_link);
6157           break;
6158
6159         default:
6160           /* FIXME: Add support for target specific section types.  */
6161 #if 0     /* Currently we do not check other section types as there are too
6162              many special cases.  Stab sections for example have a type
6163              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6164              section.  */
6165           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6166             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6167                   i, section->sh_link);
6168 #endif
6169           break;
6170         }
6171
6172       /* Check the sh_info field.  */
6173       switch (section->sh_type)
6174         {
6175         case SHT_REL:
6176         case SHT_RELA:
6177           if (section->sh_info < 1
6178               || section->sh_info >= elf_header.e_shnum
6179               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6180                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6181                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6182                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6183                   /* FIXME: Are other section types valid ?  */
6184                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6185             {
6186               if (section->sh_info == 0
6187                   && (streq (SECTION_NAME (section), ".rel.dyn")
6188                       || streq (SECTION_NAME (section), ".rela.dyn")))
6189                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6190                    of zero.  The relocations in these sections may apply
6191                    to many different sections.  */
6192                    ;
6193               else
6194                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6195                       i, section->sh_info);
6196             }
6197           break;
6198
6199         case SHT_DYNAMIC:
6200         case SHT_HASH:
6201         case SHT_SYMTAB_SHNDX:
6202         case SHT_INIT_ARRAY:
6203         case SHT_FINI_ARRAY:
6204         case SHT_PREINIT_ARRAY:
6205           if (section->sh_info != 0)
6206             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6207                   i, section->sh_info);
6208           break;
6209
6210         case SHT_GROUP:
6211         case SHT_SYMTAB:
6212         case SHT_DYNSYM:
6213           /* A symbol index - we assume that it is valid.  */
6214           break;
6215
6216         default:
6217           /* FIXME: Add support for target specific section types.  */
6218           if (section->sh_type == SHT_NOBITS)
6219             /* NOBITS section headers with non-zero sh_info fields can be
6220                created when a binary is stripped of everything but its debug
6221                information.  The stripped sections have their headers
6222                preserved but their types set to SHT_NOBITS.  So do not check
6223                this type of section.  */
6224             ;
6225           else if (section->sh_flags & SHF_INFO_LINK)
6226             {
6227               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6228                 warn (_("[%2u]: Expected link to another section in info field"), i);
6229             }
6230           else if (section->sh_type < SHT_LOOS
6231                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6232                    && section->sh_info != 0)
6233             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6234                   i, section->sh_info);
6235           break;
6236         }
6237
6238       /* Check the sh_size field.  */
6239       if (section->sh_size > current_file_size
6240           && section->sh_type != SHT_NOBITS
6241           && section->sh_type != SHT_NULL
6242           && section->sh_type < SHT_LOOS)
6243         warn (_("Size of section %u is larger than the entire file!\n"), i);
6244
6245       printf ("  [%2u] ", i);
6246       if (do_section_details)
6247         printf ("%s\n      ", printable_section_name (section));
6248       else
6249         print_symbol (-17, SECTION_NAME (section));
6250
6251       printf (do_wide ? " %-15s " : " %-15.15s ",
6252               get_section_type_name (section->sh_type));
6253
6254       if (is_32bit_elf)
6255         {
6256           const char * link_too_big = NULL;
6257
6258           print_vma (section->sh_addr, LONG_HEX);
6259
6260           printf ( " %6.6lx %6.6lx %2.2lx",
6261                    (unsigned long) section->sh_offset,
6262                    (unsigned long) section->sh_size,
6263                    (unsigned long) section->sh_entsize);
6264
6265           if (do_section_details)
6266             fputs ("  ", stdout);
6267           else
6268             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6269
6270           if (section->sh_link >= elf_header.e_shnum)
6271             {
6272               link_too_big = "";
6273               /* The sh_link value is out of range.  Normally this indicates
6274                  an error but it can have special values in Solaris binaries.  */
6275               switch (elf_header.e_machine)
6276                 {
6277                 case EM_386:
6278                 case EM_IAMCU:
6279                 case EM_X86_64:
6280                 case EM_L1OM:
6281                 case EM_K1OM:
6282                 case EM_OLD_SPARCV9:
6283                 case EM_SPARC32PLUS:
6284                 case EM_SPARCV9:
6285                 case EM_SPARC:
6286                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6287                     link_too_big = "BEFORE";
6288                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6289                     link_too_big = "AFTER";
6290                   break;
6291                 default:
6292                   break;
6293                 }
6294             }
6295
6296           if (do_section_details)
6297             {
6298               if (link_too_big != NULL && * link_too_big)
6299                 printf ("<%s> ", link_too_big);
6300               else
6301                 printf ("%2u ", section->sh_link);
6302               printf ("%3u %2lu\n", section->sh_info,
6303                       (unsigned long) section->sh_addralign);
6304             }
6305           else
6306             printf ("%2u %3u %2lu\n",
6307                     section->sh_link,
6308                     section->sh_info,
6309                     (unsigned long) section->sh_addralign);
6310
6311           if (link_too_big && ! * link_too_big)
6312             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6313                   i, section->sh_link);
6314         }
6315       else if (do_wide)
6316         {
6317           print_vma (section->sh_addr, LONG_HEX);
6318
6319           if ((long) section->sh_offset == section->sh_offset)
6320             printf (" %6.6lx", (unsigned long) section->sh_offset);
6321           else
6322             {
6323               putchar (' ');
6324               print_vma (section->sh_offset, LONG_HEX);
6325             }
6326
6327           if ((unsigned long) section->sh_size == section->sh_size)
6328             printf (" %6.6lx", (unsigned long) section->sh_size);
6329           else
6330             {
6331               putchar (' ');
6332               print_vma (section->sh_size, LONG_HEX);
6333             }
6334
6335           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6336             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6337           else
6338             {
6339               putchar (' ');
6340               print_vma (section->sh_entsize, LONG_HEX);
6341             }
6342
6343           if (do_section_details)
6344             fputs ("  ", stdout);
6345           else
6346             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6347
6348           printf ("%2u %3u ", section->sh_link, section->sh_info);
6349
6350           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6351             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6352           else
6353             {
6354               print_vma (section->sh_addralign, DEC);
6355               putchar ('\n');
6356             }
6357         }
6358       else if (do_section_details)
6359         {
6360           printf ("       %-15.15s  ",
6361                   get_section_type_name (section->sh_type));
6362           print_vma (section->sh_addr, LONG_HEX);
6363           if ((long) section->sh_offset == section->sh_offset)
6364             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6365           else
6366             {
6367               printf ("  ");
6368               print_vma (section->sh_offset, LONG_HEX);
6369             }
6370           printf ("  %u\n       ", section->sh_link);
6371           print_vma (section->sh_size, LONG_HEX);
6372           putchar (' ');
6373           print_vma (section->sh_entsize, LONG_HEX);
6374
6375           printf ("  %-16u  %lu\n",
6376                   section->sh_info,
6377                   (unsigned long) section->sh_addralign);
6378         }
6379       else
6380         {
6381           putchar (' ');
6382           print_vma (section->sh_addr, LONG_HEX);
6383           if ((long) section->sh_offset == section->sh_offset)
6384             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6385           else
6386             {
6387               printf ("  ");
6388               print_vma (section->sh_offset, LONG_HEX);
6389             }
6390           printf ("\n       ");
6391           print_vma (section->sh_size, LONG_HEX);
6392           printf ("  ");
6393           print_vma (section->sh_entsize, LONG_HEX);
6394
6395           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6396
6397           printf ("     %2u   %3u     %lu\n",
6398                   section->sh_link,
6399                   section->sh_info,
6400                   (unsigned long) section->sh_addralign);
6401         }
6402
6403       if (do_section_details)
6404         {
6405           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6406           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6407             {
6408               /* Minimum section size is 12 bytes for 32-bit compression
6409                  header + 12 bytes for compressed data header.  */
6410               unsigned char buf[24];
6411
6412               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6413               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6414                             sizeof (buf), _("compression header")))
6415                 {
6416                   Elf_Internal_Chdr chdr;
6417
6418                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6419
6420                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6421                     printf ("       ZLIB, ");
6422                   else
6423                     printf (_("       [<unknown>: 0x%x], "),
6424                             chdr.ch_type);
6425                   print_vma (chdr.ch_size, LONG_HEX);
6426                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6427                 }
6428             }
6429         }
6430     }
6431
6432   if (!do_section_details)
6433     {
6434       /* The ordering of the letters shown here matches the ordering of the
6435          corresponding SHF_xxx values, and hence the order in which these
6436          letters will be displayed to the user.  */
6437       printf (_("Key to Flags:\n\
6438   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6439   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6440   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6441       if (elf_header.e_machine == EM_X86_64
6442           || elf_header.e_machine == EM_L1OM
6443           || elf_header.e_machine == EM_K1OM)
6444         printf (_("l (large), "));
6445       else if (elf_header.e_machine == EM_ARM)
6446         printf (_("y (purecode), "));
6447       printf ("p (processor specific)\n");
6448     }
6449
6450   return TRUE;
6451 }
6452
6453 static const char *
6454 get_group_flags (unsigned int flags)
6455 {
6456   static char buff[128];
6457
6458   if (flags == 0)
6459     return "";
6460   else if (flags == GRP_COMDAT)
6461     return "COMDAT ";
6462
6463   snprintf (buff, 14, _("[0x%x: "), flags);
6464
6465   flags &= ~ GRP_COMDAT;
6466   if (flags & GRP_MASKOS)
6467     {
6468       strcat (buff, "<OS specific>");
6469       flags &= ~ GRP_MASKOS;
6470     }
6471
6472   if (flags & GRP_MASKPROC)
6473     {
6474       strcat (buff, "<PROC specific>");
6475       flags &= ~ GRP_MASKPROC;
6476     }
6477
6478   if (flags)
6479     strcat (buff, "<unknown>");
6480
6481   strcat (buff, "]");
6482   return buff;
6483 }
6484
6485 static bfd_boolean
6486 process_section_groups (FILE * file)
6487 {
6488   Elf_Internal_Shdr * section;
6489   unsigned int i;
6490   struct group * group;
6491   Elf_Internal_Shdr * symtab_sec;
6492   Elf_Internal_Shdr * strtab_sec;
6493   Elf_Internal_Sym * symtab;
6494   unsigned long num_syms;
6495   char * strtab;
6496   size_t strtab_size;
6497
6498   /* Don't process section groups unless needed.  */
6499   if (!do_unwind && !do_section_groups)
6500     return TRUE;
6501
6502   if (elf_header.e_shnum == 0)
6503     {
6504       if (do_section_groups)
6505         printf (_("\nThere are no sections to group in this file.\n"));
6506
6507       return TRUE;
6508     }
6509
6510   if (section_headers == NULL)
6511     {
6512       error (_("Section headers are not available!\n"));
6513       /* PR 13622: This can happen with a corrupt ELF header.  */
6514       return FALSE;
6515     }
6516
6517   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6518                                                      sizeof (struct group *));
6519
6520   if (section_headers_groups == NULL)
6521     {
6522       error (_("Out of memory reading %u section group headers\n"),
6523              elf_header.e_shnum);
6524       return FALSE;
6525     }
6526
6527   /* Scan the sections for the group section.  */
6528   group_count = 0;
6529   for (i = 0, section = section_headers;
6530        i < elf_header.e_shnum;
6531        i++, section++)
6532     if (section->sh_type == SHT_GROUP)
6533       group_count++;
6534
6535   if (group_count == 0)
6536     {
6537       if (do_section_groups)
6538         printf (_("\nThere are no section groups in this file.\n"));
6539
6540       return TRUE;
6541     }
6542
6543   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6544
6545   if (section_groups == NULL)
6546     {
6547       error (_("Out of memory reading %lu groups\n"),
6548              (unsigned long) group_count);
6549       return FALSE;
6550     }
6551
6552   symtab_sec = NULL;
6553   strtab_sec = NULL;
6554   symtab = NULL;
6555   num_syms = 0;
6556   strtab = NULL;
6557   strtab_size = 0;
6558   for (i = 0, section = section_headers, group = section_groups;
6559        i < elf_header.e_shnum;
6560        i++, section++)
6561     {
6562       if (section->sh_type == SHT_GROUP)
6563         {
6564           const char * name = printable_section_name (section);
6565           const char * group_name;
6566           unsigned char * start;
6567           unsigned char * indices;
6568           unsigned int entry, j, size;
6569           Elf_Internal_Shdr * sec;
6570           Elf_Internal_Sym * sym;
6571
6572           /* Get the symbol table.  */
6573           if (section->sh_link >= elf_header.e_shnum
6574               || ((sec = section_headers + section->sh_link)->sh_type
6575                   != SHT_SYMTAB))
6576             {
6577               error (_("Bad sh_link in group section `%s'\n"), name);
6578               continue;
6579             }
6580
6581           if (symtab_sec != sec)
6582             {
6583               symtab_sec = sec;
6584               if (symtab)
6585                 free (symtab);
6586               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6587             }
6588
6589           if (symtab == NULL)
6590             {
6591               error (_("Corrupt header in group section `%s'\n"), name);
6592               continue;
6593             }
6594
6595           if (section->sh_info >= num_syms)
6596             {
6597               error (_("Bad sh_info in group section `%s'\n"), name);
6598               continue;
6599             }
6600
6601           sym = symtab + section->sh_info;
6602
6603           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6604             {
6605               if (sym->st_shndx == 0
6606                   || sym->st_shndx >= elf_header.e_shnum)
6607                 {
6608                   error (_("Bad sh_info in group section `%s'\n"), name);
6609                   continue;
6610                 }
6611
6612               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6613               strtab_sec = NULL;
6614               if (strtab)
6615                 free (strtab);
6616               strtab = NULL;
6617               strtab_size = 0;
6618             }
6619           else
6620             {
6621               /* Get the string table.  */
6622               if (symtab_sec->sh_link >= elf_header.e_shnum)
6623                 {
6624                   strtab_sec = NULL;
6625                   if (strtab)
6626                     free (strtab);
6627                   strtab = NULL;
6628                   strtab_size = 0;
6629                 }
6630               else if (strtab_sec
6631                        != (sec = section_headers + symtab_sec->sh_link))
6632                 {
6633                   strtab_sec = sec;
6634                   if (strtab)
6635                     free (strtab);
6636
6637                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6638                                               1, strtab_sec->sh_size,
6639                                               _("string table"));
6640                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6641                 }
6642               group_name = sym->st_name < strtab_size
6643                 ? strtab + sym->st_name : _("<corrupt>");
6644             }
6645
6646           /* PR 17531: file: loop.  */
6647           if (section->sh_entsize > section->sh_size)
6648             {
6649               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6650                      printable_section_name (section),
6651                      (unsigned long) section->sh_entsize,
6652                      (unsigned long) section->sh_size);
6653               break;
6654             }
6655
6656           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6657                                               1, section->sh_size,
6658                                               _("section data"));
6659           if (start == NULL)
6660             continue;
6661
6662           indices = start;
6663           size = (section->sh_size / section->sh_entsize) - 1;
6664           entry = byte_get (indices, 4);
6665           indices += 4;
6666
6667           if (do_section_groups)
6668             {
6669               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6670                       get_group_flags (entry), i, name, group_name, size);
6671
6672               printf (_("   [Index]    Name\n"));
6673             }
6674
6675           group->group_index = i;
6676
6677           for (j = 0; j < size; j++)
6678             {
6679               struct group_list * g;
6680
6681               entry = byte_get (indices, 4);
6682               indices += 4;
6683
6684               if (entry >= elf_header.e_shnum)
6685                 {
6686                   static unsigned num_group_errors = 0;
6687
6688                   if (num_group_errors ++ < 10)
6689                     {
6690                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6691                              entry, i, elf_header.e_shnum - 1);
6692                       if (num_group_errors == 10)
6693                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6694                     }
6695                   continue;
6696                 }
6697
6698               if (section_headers_groups [entry] != NULL)
6699                 {
6700                   if (entry)
6701                     {
6702                       static unsigned num_errs = 0;
6703
6704                       if (num_errs ++ < 10)
6705                         {
6706                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6707                                  entry, i,
6708                                  section_headers_groups [entry]->group_index);
6709                           if (num_errs == 10)
6710                             warn (_("Further error messages about already contained group sections suppressed\n"));
6711                         }
6712                       continue;
6713                     }
6714                   else
6715                     {
6716                       /* Intel C/C++ compiler may put section 0 in a
6717                          section group.  We just warn it the first time
6718                          and ignore it afterwards.  */
6719                       static bfd_boolean warned = FALSE;
6720                       if (!warned)
6721                         {
6722                           error (_("section 0 in group section [%5u]\n"),
6723                                  section_headers_groups [entry]->group_index);
6724                           warned = TRUE;
6725                         }
6726                     }
6727                 }
6728
6729               section_headers_groups [entry] = group;
6730
6731               if (do_section_groups)
6732                 {
6733                   sec = section_headers + entry;
6734                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6735                 }
6736
6737               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6738               g->section_index = entry;
6739               g->next = group->root;
6740               group->root = g;
6741             }
6742
6743           if (start)
6744             free (start);
6745
6746           group++;
6747         }
6748     }
6749
6750   if (symtab)
6751     free (symtab);
6752   if (strtab)
6753     free (strtab);
6754   return TRUE;
6755 }
6756
6757 /* Data used to display dynamic fixups.  */
6758
6759 struct ia64_vms_dynfixup
6760 {
6761   bfd_vma needed_ident;         /* Library ident number.  */
6762   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6763   bfd_vma fixup_needed;         /* Index of the library.  */
6764   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6765   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6766 };
6767
6768 /* Data used to display dynamic relocations.  */
6769
6770 struct ia64_vms_dynimgrela
6771 {
6772   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6773   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6774 };
6775
6776 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6777    library).  */
6778
6779 static bfd_boolean
6780 dump_ia64_vms_dynamic_fixups (FILE * file,
6781                               struct ia64_vms_dynfixup * fixup,
6782                               const char * strtab,
6783                               unsigned int strtab_sz)
6784 {
6785   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6786   long i;
6787   const char * lib_name;
6788
6789   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6790                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6791                    _("dynamic section image fixups"));
6792   if (!imfs)
6793     return FALSE;
6794
6795   if (fixup->needed < strtab_sz)
6796     lib_name = strtab + fixup->needed;
6797   else
6798     {
6799       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6800             (unsigned long) fixup->needed);
6801       lib_name = "???";
6802     }
6803   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6804           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6805   printf
6806     (_("Seg Offset           Type                             SymVec DataType\n"));
6807
6808   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6809     {
6810       unsigned int type;
6811       const char *rtype;
6812
6813       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6814       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6815       type = BYTE_GET (imfs [i].type);
6816       rtype = elf_ia64_reloc_type (type);
6817       if (rtype == NULL)
6818         printf (" 0x%08x                       ", type);
6819       else
6820         printf (" %-32s ", rtype);
6821       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6822       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6823     }
6824
6825   free (imfs);
6826   return TRUE;
6827 }
6828
6829 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6830
6831 static bfd_boolean
6832 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6833 {
6834   Elf64_External_VMS_IMAGE_RELA *imrs;
6835   long i;
6836
6837   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6838                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6839                    _("dynamic section image relocations"));
6840   if (!imrs)
6841     return FALSE;
6842
6843   printf (_("\nImage relocs\n"));
6844   printf
6845     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6846
6847   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6848     {
6849       unsigned int type;
6850       const char *rtype;
6851
6852       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6853       printf ("%08" BFD_VMA_FMT "x ",
6854               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6855       type = BYTE_GET (imrs [i].type);
6856       rtype = elf_ia64_reloc_type (type);
6857       if (rtype == NULL)
6858         printf ("0x%08x                      ", type);
6859       else
6860         printf ("%-31s ", rtype);
6861       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6862       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6863       printf ("%08" BFD_VMA_FMT "x\n",
6864               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6865     }
6866
6867   free (imrs);
6868   return TRUE;
6869 }
6870
6871 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6872
6873 static bfd_boolean
6874 process_ia64_vms_dynamic_relocs (FILE *file)
6875 {
6876   struct ia64_vms_dynfixup fixup;
6877   struct ia64_vms_dynimgrela imgrela;
6878   Elf_Internal_Dyn *entry;
6879   bfd_vma strtab_off = 0;
6880   bfd_vma strtab_sz = 0;
6881   char *strtab = NULL;
6882   bfd_boolean res = TRUE;
6883
6884   memset (&fixup, 0, sizeof (fixup));
6885   memset (&imgrela, 0, sizeof (imgrela));
6886
6887   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6888   for (entry = dynamic_section;
6889        entry < dynamic_section + dynamic_nent;
6890        entry++)
6891     {
6892       switch (entry->d_tag)
6893         {
6894         case DT_IA_64_VMS_STRTAB_OFFSET:
6895           strtab_off = entry->d_un.d_val;
6896           break;
6897         case DT_STRSZ:
6898           strtab_sz = entry->d_un.d_val;
6899           if (strtab == NULL)
6900             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6901                                1, strtab_sz, _("dynamic string section"));
6902           break;
6903
6904         case DT_IA_64_VMS_NEEDED_IDENT:
6905           fixup.needed_ident = entry->d_un.d_val;
6906           break;
6907         case DT_NEEDED:
6908           fixup.needed = entry->d_un.d_val;
6909           break;
6910         case DT_IA_64_VMS_FIXUP_NEEDED:
6911           fixup.fixup_needed = entry->d_un.d_val;
6912           break;
6913         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6914           fixup.fixup_rela_cnt = entry->d_un.d_val;
6915           break;
6916         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6917           fixup.fixup_rela_off = entry->d_un.d_val;
6918           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6919             res = FALSE;
6920           break;
6921         case DT_IA_64_VMS_IMG_RELA_CNT:
6922           imgrela.img_rela_cnt = entry->d_un.d_val;
6923           break;
6924         case DT_IA_64_VMS_IMG_RELA_OFF:
6925           imgrela.img_rela_off = entry->d_un.d_val;
6926           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6927             res = FALSE;
6928           break;
6929
6930         default:
6931           break;
6932         }
6933     }
6934
6935   if (strtab != NULL)
6936     free (strtab);
6937
6938   return res;
6939 }
6940
6941 static struct
6942 {
6943   const char * name;
6944   int reloc;
6945   int size;
6946   int rela;
6947 }
6948   dynamic_relocations [] =
6949 {
6950   { "REL", DT_REL, DT_RELSZ, FALSE },
6951   { "RELA", DT_RELA, DT_RELASZ, TRUE },
6952   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6953 };
6954
6955 /* Process the reloc section.  */
6956
6957 static bfd_boolean
6958 process_relocs (FILE * file)
6959 {
6960   unsigned long rel_size;
6961   unsigned long rel_offset;
6962
6963   if (!do_reloc)
6964     return TRUE;
6965
6966   if (do_using_dynamic)
6967     {
6968       int          is_rela;
6969       const char * name;
6970       bfd_boolean  has_dynamic_reloc;
6971       unsigned int i;
6972
6973       has_dynamic_reloc = FALSE;
6974
6975       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6976         {
6977           is_rela = dynamic_relocations [i].rela;
6978           name = dynamic_relocations [i].name;
6979           rel_size = dynamic_info [dynamic_relocations [i].size];
6980           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6981
6982           if (rel_size)
6983             has_dynamic_reloc = TRUE;
6984
6985           if (is_rela == UNKNOWN)
6986             {
6987               if (dynamic_relocations [i].reloc == DT_JMPREL)
6988                 switch (dynamic_info[DT_PLTREL])
6989                   {
6990                   case DT_REL:
6991                     is_rela = FALSE;
6992                     break;
6993                   case DT_RELA:
6994                     is_rela = TRUE;
6995                     break;
6996                   }
6997             }
6998
6999           if (rel_size)
7000             {
7001               printf
7002                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7003                  name, rel_offset, rel_size);
7004
7005               dump_relocations (file,
7006                                 offset_from_vma (file, rel_offset, rel_size),
7007                                 rel_size,
7008                                 dynamic_symbols, num_dynamic_syms,
7009                                 dynamic_strings, dynamic_strings_length,
7010                                 is_rela, TRUE /* is_dynamic */);
7011             }
7012         }
7013
7014       if (is_ia64_vms ())
7015         if (process_ia64_vms_dynamic_relocs (file))
7016           has_dynamic_reloc = TRUE;
7017
7018       if (! has_dynamic_reloc)
7019         printf (_("\nThere are no dynamic relocations in this file.\n"));
7020     }
7021   else
7022     {
7023       Elf_Internal_Shdr * section;
7024       unsigned long i;
7025       bfd_boolean found = FALSE;
7026
7027       for (i = 0, section = section_headers;
7028            i < elf_header.e_shnum;
7029            i++, section++)
7030         {
7031           if (   section->sh_type != SHT_RELA
7032               && section->sh_type != SHT_REL)
7033             continue;
7034
7035           rel_offset = section->sh_offset;
7036           rel_size   = section->sh_size;
7037
7038           if (rel_size)
7039             {
7040               Elf_Internal_Shdr * strsec;
7041               int is_rela;
7042
7043               printf (_("\nRelocation section "));
7044
7045               if (string_table == NULL)
7046                 printf ("%d", section->sh_name);
7047               else
7048                 printf ("'%s'", printable_section_name (section));
7049
7050               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7051                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7052
7053               is_rela = section->sh_type == SHT_RELA;
7054
7055               if (section->sh_link != 0
7056                   && section->sh_link < elf_header.e_shnum)
7057                 {
7058                   Elf_Internal_Shdr * symsec;
7059                   Elf_Internal_Sym *  symtab;
7060                   unsigned long nsyms;
7061                   unsigned long strtablen = 0;
7062                   char * strtab = NULL;
7063
7064                   symsec = section_headers + section->sh_link;
7065                   if (symsec->sh_type != SHT_SYMTAB
7066                       && symsec->sh_type != SHT_DYNSYM)
7067                     continue;
7068
7069                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7070
7071                   if (symtab == NULL)
7072                     continue;
7073
7074                   if (symsec->sh_link != 0
7075                       && symsec->sh_link < elf_header.e_shnum)
7076                     {
7077                       strsec = section_headers + symsec->sh_link;
7078
7079                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7080                                                   1, strsec->sh_size,
7081                                                   _("string table"));
7082                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7083                     }
7084
7085                   dump_relocations (file, rel_offset, rel_size,
7086                                     symtab, nsyms, strtab, strtablen,
7087                                     is_rela,
7088                                     symsec->sh_type == SHT_DYNSYM);
7089                   if (strtab)
7090                     free (strtab);
7091                   free (symtab);
7092                 }
7093               else
7094                 dump_relocations (file, rel_offset, rel_size,
7095                                   NULL, 0, NULL, 0, is_rela,
7096                                   FALSE /* is_dynamic */);
7097
7098               found = TRUE;
7099             }
7100         }
7101
7102       if (! found)
7103         printf (_("\nThere are no relocations in this file.\n"));
7104     }
7105
7106   return TRUE;
7107 }
7108
7109 /* An absolute address consists of a section and an offset.  If the
7110    section is NULL, the offset itself is the address, otherwise, the
7111    address equals to LOAD_ADDRESS(section) + offset.  */
7112
7113 struct absaddr
7114 {
7115   unsigned short section;
7116   bfd_vma offset;
7117 };
7118
7119 #define ABSADDR(a) \
7120   ((a).section \
7121    ? section_headers [(a).section].sh_addr + (a).offset \
7122    : (a).offset)
7123
7124 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7125    name, if found, and the offset from the symbol to ADDR.  */
7126
7127 static void
7128 find_symbol_for_address (Elf_Internal_Sym * symtab,
7129                          unsigned long      nsyms,
7130                          const char *       strtab,
7131                          unsigned long      strtab_size,
7132                          struct absaddr     addr,
7133                          const char **      symname,
7134                          bfd_vma *          offset)
7135 {
7136   bfd_vma dist = 0x100000;
7137   Elf_Internal_Sym * sym;
7138   Elf_Internal_Sym * beg;
7139   Elf_Internal_Sym * end;
7140   Elf_Internal_Sym * best = NULL;
7141
7142   REMOVE_ARCH_BITS (addr.offset);
7143   beg = symtab;
7144   end = symtab + nsyms;
7145
7146   while (beg < end)
7147     {
7148       bfd_vma value;
7149
7150       sym = beg + (end - beg) / 2;
7151
7152       value = sym->st_value;
7153       REMOVE_ARCH_BITS (value);
7154
7155       if (sym->st_name != 0
7156           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7157           && addr.offset >= value
7158           && addr.offset - value < dist)
7159         {
7160           best = sym;
7161           dist = addr.offset - value;
7162           if (!dist)
7163             break;
7164         }
7165
7166       if (addr.offset < value)
7167         end = sym;
7168       else
7169         beg = sym + 1;
7170     }
7171
7172   if (best)
7173     {
7174       *symname = (best->st_name >= strtab_size
7175                   ? _("<corrupt>") : strtab + best->st_name);
7176       *offset = dist;
7177       return;
7178     }
7179
7180   *symname = NULL;
7181   *offset = addr.offset;
7182 }
7183
7184 static /* signed */ int
7185 symcmp (const void *p, const void *q)
7186 {
7187   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7188   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7189
7190   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7191 }
7192
7193 /* Process the unwind section.  */
7194
7195 #include "unwind-ia64.h"
7196
7197 struct ia64_unw_table_entry
7198 {
7199   struct absaddr start;
7200   struct absaddr end;
7201   struct absaddr info;
7202 };
7203
7204 struct ia64_unw_aux_info
7205 {
7206   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7207   unsigned long                 table_len;      /* Length of unwind table.  */
7208   unsigned char *               info;           /* Unwind info.  */
7209   unsigned long                 info_size;      /* Size of unwind info.  */
7210   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7211   bfd_vma                       seg_base;       /* Starting address of segment.  */
7212   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7213   unsigned long                 nsyms;          /* Number of symbols.  */
7214   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7215   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7216   char *                        strtab;         /* The string table.  */
7217   unsigned long                 strtab_size;    /* Size of string table.  */
7218 };
7219
7220 static bfd_boolean
7221 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7222 {
7223   struct ia64_unw_table_entry * tp;
7224   unsigned long j, nfuns;
7225   int in_body;
7226   bfd_boolean res = TRUE;
7227
7228   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7229   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7230     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7231       aux->funtab[nfuns++] = aux->symtab[j];
7232   aux->nfuns = nfuns;
7233   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7234
7235   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7236     {
7237       bfd_vma stamp;
7238       bfd_vma offset;
7239       const unsigned char * dp;
7240       const unsigned char * head;
7241       const unsigned char * end;
7242       const char * procname;
7243
7244       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7245                                aux->strtab_size, tp->start, &procname, &offset);
7246
7247       fputs ("\n<", stdout);
7248
7249       if (procname)
7250         {
7251           fputs (procname, stdout);
7252
7253           if (offset)
7254             printf ("+%lx", (unsigned long) offset);
7255         }
7256
7257       fputs (">: [", stdout);
7258       print_vma (tp->start.offset, PREFIX_HEX);
7259       fputc ('-', stdout);
7260       print_vma (tp->end.offset, PREFIX_HEX);
7261       printf ("], info at +0x%lx\n",
7262               (unsigned long) (tp->info.offset - aux->seg_base));
7263
7264       /* PR 17531: file: 86232b32.  */
7265       if (aux->info == NULL)
7266         continue;
7267
7268       /* PR 17531: file: 0997b4d1.  */
7269       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7270         {
7271           warn (_("Invalid offset %lx in table entry %ld\n"),
7272                 (long) tp->info.offset, (long) (tp - aux->table));
7273           res = FALSE;
7274           continue;
7275         }
7276
7277       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7278       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7279
7280       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7281               (unsigned) UNW_VER (stamp),
7282               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7283               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7284               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7285               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7286
7287       if (UNW_VER (stamp) != 1)
7288         {
7289           printf (_("\tUnknown version.\n"));
7290           continue;
7291         }
7292
7293       in_body = 0;
7294       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7295       /* PR 17531: file: 16ceda89.  */
7296       if (end > aux->info + aux->info_size)
7297         end = aux->info + aux->info_size;
7298       for (dp = head + 8; dp < end;)
7299         dp = unw_decode (dp, in_body, & in_body, end);
7300     }
7301
7302   free (aux->funtab);
7303
7304   return res;
7305 }
7306
7307 static bfd_boolean
7308 slurp_ia64_unwind_table (FILE * file,
7309                          struct ia64_unw_aux_info * aux,
7310                          Elf_Internal_Shdr * sec)
7311 {
7312   unsigned long size, nrelas, i;
7313   Elf_Internal_Phdr * seg;
7314   struct ia64_unw_table_entry * tep;
7315   Elf_Internal_Shdr * relsec;
7316   Elf_Internal_Rela * rela;
7317   Elf_Internal_Rela * rp;
7318   unsigned char * table;
7319   unsigned char * tp;
7320   Elf_Internal_Sym * sym;
7321   const char * relname;
7322
7323   aux->table_len = 0;
7324
7325   /* First, find the starting address of the segment that includes
7326      this section: */
7327
7328   if (elf_header.e_phnum)
7329     {
7330       if (! get_program_headers (file))
7331           return FALSE;
7332
7333       for (seg = program_headers;
7334            seg < program_headers + elf_header.e_phnum;
7335            ++seg)
7336         {
7337           if (seg->p_type != PT_LOAD)
7338             continue;
7339
7340           if (sec->sh_addr >= seg->p_vaddr
7341               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7342             {
7343               aux->seg_base = seg->p_vaddr;
7344               break;
7345             }
7346         }
7347     }
7348
7349   /* Second, build the unwind table from the contents of the unwind section:  */
7350   size = sec->sh_size;
7351   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7352                                       _("unwind table"));
7353   if (!table)
7354     return FALSE;
7355
7356   aux->table_len = size / (3 * eh_addr_size);
7357   aux->table = (struct ia64_unw_table_entry *)
7358     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7359   tep = aux->table;
7360
7361   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7362     {
7363       tep->start.section = SHN_UNDEF;
7364       tep->end.section   = SHN_UNDEF;
7365       tep->info.section  = SHN_UNDEF;
7366       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7367       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7368       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7369       tep->start.offset += aux->seg_base;
7370       tep->end.offset   += aux->seg_base;
7371       tep->info.offset  += aux->seg_base;
7372     }
7373   free (table);
7374
7375   /* Third, apply any relocations to the unwind table:  */
7376   for (relsec = section_headers;
7377        relsec < section_headers + elf_header.e_shnum;
7378        ++relsec)
7379     {
7380       if (relsec->sh_type != SHT_RELA
7381           || relsec->sh_info >= elf_header.e_shnum
7382           || section_headers + relsec->sh_info != sec)
7383         continue;
7384
7385       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7386                               & rela, & nrelas))
7387         {
7388           free (aux->table);
7389           aux->table = NULL;
7390           aux->table_len = 0;
7391           return FALSE;
7392         }
7393
7394       for (rp = rela; rp < rela + nrelas; ++rp)
7395         {
7396           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7397           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7398
7399           /* PR 17531: file: 9fa67536.  */
7400           if (relname == NULL)
7401             {
7402               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7403               continue;
7404             }
7405
7406           if (! const_strneq (relname, "R_IA64_SEGREL"))
7407             {
7408               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7409               continue;
7410             }
7411
7412           i = rp->r_offset / (3 * eh_addr_size);
7413
7414           /* PR 17531: file: 5bc8d9bf.  */
7415           if (i >= aux->table_len)
7416             {
7417               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7418               continue;
7419             }
7420
7421           switch (rp->r_offset / eh_addr_size % 3)
7422             {
7423             case 0:
7424               aux->table[i].start.section = sym->st_shndx;
7425               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7426               break;
7427             case 1:
7428               aux->table[i].end.section   = sym->st_shndx;
7429               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7430               break;
7431             case 2:
7432               aux->table[i].info.section  = sym->st_shndx;
7433               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7434               break;
7435             default:
7436               break;
7437             }
7438         }
7439
7440       free (rela);
7441     }
7442
7443   return TRUE;
7444 }
7445
7446 static bfd_boolean
7447 ia64_process_unwind (FILE * file)
7448 {
7449   Elf_Internal_Shdr * sec;
7450   Elf_Internal_Shdr * unwsec = NULL;
7451   Elf_Internal_Shdr * strsec;
7452   unsigned long i, unwcount = 0, unwstart = 0;
7453   struct ia64_unw_aux_info aux;
7454   bfd_boolean res = TRUE;
7455
7456   memset (& aux, 0, sizeof (aux));
7457
7458   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7459     {
7460       if (sec->sh_type == SHT_SYMTAB
7461           && sec->sh_link < elf_header.e_shnum)
7462         {
7463           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7464
7465           strsec = section_headers + sec->sh_link;
7466           if (aux.strtab != NULL)
7467             {
7468               error (_("Multiple auxillary string tables encountered\n"));
7469               free (aux.strtab);
7470               res = FALSE;
7471             }
7472           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7473                                           1, strsec->sh_size,
7474                                           _("string table"));
7475           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7476         }
7477       else if (sec->sh_type == SHT_IA_64_UNWIND)
7478         unwcount++;
7479     }
7480
7481   if (!unwcount)
7482     printf (_("\nThere are no unwind sections in this file.\n"));
7483
7484   while (unwcount-- > 0)
7485     {
7486       char * suffix;
7487       size_t len, len2;
7488
7489       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7490            i < elf_header.e_shnum; ++i, ++sec)
7491         if (sec->sh_type == SHT_IA_64_UNWIND)
7492           {
7493             unwsec = sec;
7494             break;
7495           }
7496       /* We have already counted the number of SHT_IA64_UNWIND
7497          sections so the loop above should never fail.  */
7498       assert (unwsec != NULL);
7499
7500       unwstart = i + 1;
7501       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7502
7503       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7504         {
7505           /* We need to find which section group it is in.  */
7506           struct group_list * g;
7507
7508           if (section_headers_groups == NULL
7509               || section_headers_groups [i] == NULL)
7510             i = elf_header.e_shnum;
7511           else
7512             {
7513               g = section_headers_groups [i]->root;
7514
7515               for (; g != NULL; g = g->next)
7516                 {
7517                   sec = section_headers + g->section_index;
7518
7519                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7520                     break;
7521                 }
7522
7523               if (g == NULL)
7524                 i = elf_header.e_shnum;
7525             }
7526         }
7527       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7528         {
7529           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7530           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7531           suffix = SECTION_NAME (unwsec) + len;
7532           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7533                ++i, ++sec)
7534             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7535                 && streq (SECTION_NAME (sec) + len2, suffix))
7536               break;
7537         }
7538       else
7539         {
7540           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7541              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7542           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7543           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7544           suffix = "";
7545           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
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, len2)
7550                 && streq (SECTION_NAME (sec) + len2, suffix))
7551               break;
7552         }
7553
7554       if (i == elf_header.e_shnum)
7555         {
7556           printf (_("\nCould not find unwind info section for "));
7557
7558           if (string_table == NULL)
7559             printf ("%d", unwsec->sh_name);
7560           else
7561             printf ("'%s'", printable_section_name (unwsec));
7562         }
7563       else
7564         {
7565           aux.info_addr = sec->sh_addr;
7566           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7567                                                  sec->sh_size,
7568                                                  _("unwind info"));
7569           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7570
7571           printf (_("\nUnwind section "));
7572
7573           if (string_table == NULL)
7574             printf ("%d", unwsec->sh_name);
7575           else
7576             printf ("'%s'", printable_section_name (unwsec));
7577
7578           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7579                   (unsigned long) unwsec->sh_offset,
7580                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7581
7582           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7583               && aux.table_len > 0)
7584             dump_ia64_unwind (& aux);
7585
7586           if (aux.table)
7587             free ((char *) aux.table);
7588           if (aux.info)
7589             free ((char *) aux.info);
7590           aux.table = NULL;
7591           aux.info = NULL;
7592         }
7593     }
7594
7595   if (aux.symtab)
7596     free (aux.symtab);
7597   if (aux.strtab)
7598     free ((char *) aux.strtab);
7599
7600   return res;
7601 }
7602
7603 struct hppa_unw_table_entry
7604 {
7605   struct absaddr start;
7606   struct absaddr end;
7607   unsigned int Cannot_unwind:1;                 /* 0 */
7608   unsigned int Millicode:1;                     /* 1 */
7609   unsigned int Millicode_save_sr0:1;            /* 2 */
7610   unsigned int Region_description:2;            /* 3..4 */
7611   unsigned int reserved1:1;                     /* 5 */
7612   unsigned int Entry_SR:1;                      /* 6 */
7613   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7614   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7615   unsigned int Args_stored:1;                   /* 16 */
7616   unsigned int Variable_Frame:1;                /* 17 */
7617   unsigned int Separate_Package_Body:1;         /* 18 */
7618   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7619   unsigned int Stack_Overflow_Check:1;          /* 20 */
7620   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7621   unsigned int Ada_Region:1;                    /* 22 */
7622   unsigned int cxx_info:1;                      /* 23 */
7623   unsigned int cxx_try_catch:1;                 /* 24 */
7624   unsigned int sched_entry_seq:1;               /* 25 */
7625   unsigned int reserved2:1;                     /* 26 */
7626   unsigned int Save_SP:1;                       /* 27 */
7627   unsigned int Save_RP:1;                       /* 28 */
7628   unsigned int Save_MRP_in_frame:1;             /* 29 */
7629   unsigned int extn_ptr_defined:1;              /* 30 */
7630   unsigned int Cleanup_defined:1;               /* 31 */
7631
7632   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7633   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7634   unsigned int Large_frame:1;                   /* 2 */
7635   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7636   unsigned int reserved4:1;                     /* 4 */
7637   unsigned int Total_frame_size:27;             /* 5..31 */
7638 };
7639
7640 struct hppa_unw_aux_info
7641 {
7642   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7643   unsigned long                  table_len;     /* Length of unwind table.  */
7644   bfd_vma                        seg_base;      /* Starting address of segment.  */
7645   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7646   unsigned long                  nsyms;         /* Number of symbols.  */
7647   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7648   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7649   char *                         strtab;        /* The string table.  */
7650   unsigned long                  strtab_size;   /* Size of string table.  */
7651 };
7652
7653 static bfd_boolean
7654 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7655 {
7656   struct hppa_unw_table_entry * tp;
7657   unsigned long j, nfuns;
7658   bfd_boolean res = TRUE;
7659
7660   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7661   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7662     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7663       aux->funtab[nfuns++] = aux->symtab[j];
7664   aux->nfuns = nfuns;
7665   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7666
7667   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7668     {
7669       bfd_vma offset;
7670       const char * procname;
7671
7672       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7673                                aux->strtab_size, tp->start, &procname,
7674                                &offset);
7675
7676       fputs ("\n<", stdout);
7677
7678       if (procname)
7679         {
7680           fputs (procname, stdout);
7681
7682           if (offset)
7683             printf ("+%lx", (unsigned long) offset);
7684         }
7685
7686       fputs (">: [", stdout);
7687       print_vma (tp->start.offset, PREFIX_HEX);
7688       fputc ('-', stdout);
7689       print_vma (tp->end.offset, PREFIX_HEX);
7690       printf ("]\n\t");
7691
7692 #define PF(_m) if (tp->_m) printf (#_m " ");
7693 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7694       PF(Cannot_unwind);
7695       PF(Millicode);
7696       PF(Millicode_save_sr0);
7697       /* PV(Region_description);  */
7698       PF(Entry_SR);
7699       PV(Entry_FR);
7700       PV(Entry_GR);
7701       PF(Args_stored);
7702       PF(Variable_Frame);
7703       PF(Separate_Package_Body);
7704       PF(Frame_Extension_Millicode);
7705       PF(Stack_Overflow_Check);
7706       PF(Two_Instruction_SP_Increment);
7707       PF(Ada_Region);
7708       PF(cxx_info);
7709       PF(cxx_try_catch);
7710       PF(sched_entry_seq);
7711       PF(Save_SP);
7712       PF(Save_RP);
7713       PF(Save_MRP_in_frame);
7714       PF(extn_ptr_defined);
7715       PF(Cleanup_defined);
7716       PF(MPE_XL_interrupt_marker);
7717       PF(HP_UX_interrupt_marker);
7718       PF(Large_frame);
7719       PF(Pseudo_SP_Set);
7720       PV(Total_frame_size);
7721 #undef PF
7722 #undef PV
7723     }
7724
7725   printf ("\n");
7726
7727   free (aux->funtab);
7728
7729   return res;
7730 }
7731
7732 static bfd_boolean
7733 slurp_hppa_unwind_table (FILE * file,
7734                          struct hppa_unw_aux_info * aux,
7735                          Elf_Internal_Shdr * sec)
7736 {
7737   unsigned long size, unw_ent_size, nentries, nrelas, i;
7738   Elf_Internal_Phdr * seg;
7739   struct hppa_unw_table_entry * tep;
7740   Elf_Internal_Shdr * relsec;
7741   Elf_Internal_Rela * rela;
7742   Elf_Internal_Rela * rp;
7743   unsigned char * table;
7744   unsigned char * tp;
7745   Elf_Internal_Sym * sym;
7746   const char * relname;
7747
7748   /* First, find the starting address of the segment that includes
7749      this section.  */
7750   if (elf_header.e_phnum)
7751     {
7752       if (! get_program_headers (file))
7753         return FALSE;
7754
7755       for (seg = program_headers;
7756            seg < program_headers + elf_header.e_phnum;
7757            ++seg)
7758         {
7759           if (seg->p_type != PT_LOAD)
7760             continue;
7761
7762           if (sec->sh_addr >= seg->p_vaddr
7763               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7764             {
7765               aux->seg_base = seg->p_vaddr;
7766               break;
7767             }
7768         }
7769     }
7770
7771   /* Second, build the unwind table from the contents of the unwind
7772      section.  */
7773   size = sec->sh_size;
7774   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7775                                       _("unwind table"));
7776   if (!table)
7777     return FALSE;
7778
7779   unw_ent_size = 16;
7780   nentries = size / unw_ent_size;
7781   size = unw_ent_size * nentries;
7782
7783   tep = aux->table = (struct hppa_unw_table_entry *)
7784       xcmalloc (nentries, sizeof (aux->table[0]));
7785
7786   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7787     {
7788       unsigned int tmp1, tmp2;
7789
7790       tep->start.section = SHN_UNDEF;
7791       tep->end.section   = SHN_UNDEF;
7792
7793       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7794       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7795       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7796       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7797
7798       tep->start.offset += aux->seg_base;
7799       tep->end.offset   += aux->seg_base;
7800
7801       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7802       tep->Millicode = (tmp1 >> 30) & 0x1;
7803       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7804       tep->Region_description = (tmp1 >> 27) & 0x3;
7805       tep->reserved1 = (tmp1 >> 26) & 0x1;
7806       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7807       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7808       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7809       tep->Args_stored = (tmp1 >> 15) & 0x1;
7810       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7811       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7812       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7813       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7814       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7815       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7816       tep->cxx_info = (tmp1 >> 8) & 0x1;
7817       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7818       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7819       tep->reserved2 = (tmp1 >> 5) & 0x1;
7820       tep->Save_SP = (tmp1 >> 4) & 0x1;
7821       tep->Save_RP = (tmp1 >> 3) & 0x1;
7822       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7823       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7824       tep->Cleanup_defined = tmp1 & 0x1;
7825
7826       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7827       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7828       tep->Large_frame = (tmp2 >> 29) & 0x1;
7829       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7830       tep->reserved4 = (tmp2 >> 27) & 0x1;
7831       tep->Total_frame_size = tmp2 & 0x7ffffff;
7832     }
7833   free (table);
7834
7835   /* Third, apply any relocations to the unwind table.  */
7836   for (relsec = section_headers;
7837        relsec < section_headers + elf_header.e_shnum;
7838        ++relsec)
7839     {
7840       if (relsec->sh_type != SHT_RELA
7841           || relsec->sh_info >= elf_header.e_shnum
7842           || section_headers + relsec->sh_info != sec)
7843         continue;
7844
7845       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7846                               & rela, & nrelas))
7847         return FALSE;
7848
7849       for (rp = rela; rp < rela + nrelas; ++rp)
7850         {
7851           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7852           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7853
7854           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7855           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7856             {
7857               warn (_("Skipping unexpected relocation type %s\n"), relname);
7858               continue;
7859             }
7860
7861           i = rp->r_offset / unw_ent_size;
7862
7863           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7864             {
7865             case 0:
7866               aux->table[i].start.section = sym->st_shndx;
7867               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7868               break;
7869             case 1:
7870               aux->table[i].end.section   = sym->st_shndx;
7871               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7872               break;
7873             default:
7874               break;
7875             }
7876         }
7877
7878       free (rela);
7879     }
7880
7881   aux->table_len = nentries;
7882
7883   return TRUE;
7884 }
7885
7886 static bfd_boolean
7887 hppa_process_unwind (FILE * file)
7888 {
7889   struct hppa_unw_aux_info aux;
7890   Elf_Internal_Shdr * unwsec = NULL;
7891   Elf_Internal_Shdr * strsec;
7892   Elf_Internal_Shdr * sec;
7893   unsigned long i;
7894   bfd_boolean res = TRUE;
7895
7896   if (string_table == NULL)
7897     return FALSE;
7898
7899   memset (& aux, 0, sizeof (aux));
7900
7901   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7902     {
7903       if (sec->sh_type == SHT_SYMTAB
7904           && sec->sh_link < elf_header.e_shnum)
7905         {
7906           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7907
7908           strsec = section_headers + sec->sh_link;
7909           if (aux.strtab != NULL)
7910             {
7911               error (_("Multiple auxillary string tables encountered\n"));
7912               free (aux.strtab);
7913               res = FALSE;
7914             }
7915           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7916                                           1, strsec->sh_size,
7917                                           _("string table"));
7918           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7919         }
7920       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7921         unwsec = sec;
7922     }
7923
7924   if (!unwsec)
7925     printf (_("\nThere are no unwind sections in this file.\n"));
7926
7927   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7928     {
7929       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7930         {
7931           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7932                   printable_section_name (sec),
7933                   (unsigned long) sec->sh_offset,
7934                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7935
7936           if (! slurp_hppa_unwind_table (file, &aux, sec))
7937             res = FALSE;
7938
7939           if (aux.table_len > 0)
7940             {
7941               if (! dump_hppa_unwind (&aux))
7942                 res = FALSE;
7943             }
7944
7945           if (aux.table)
7946             free ((char *) aux.table);
7947           aux.table = NULL;
7948         }
7949     }
7950
7951   if (aux.symtab)
7952     free (aux.symtab);
7953   if (aux.strtab)
7954     free ((char *) aux.strtab);
7955
7956   return res;
7957 }
7958
7959 struct arm_section
7960 {
7961   unsigned char *      data;            /* The unwind data.  */
7962   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7963   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7964   unsigned long        nrelas;          /* The number of relocations.  */
7965   unsigned int         rel_type;        /* REL or RELA ?  */
7966   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7967 };
7968
7969 struct arm_unw_aux_info
7970 {
7971   FILE *              file;             /* The file containing the unwind sections.  */
7972   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7973   unsigned long       nsyms;            /* Number of symbols.  */
7974   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7975   unsigned long       nfuns;            /* Number of these symbols.  */
7976   char *              strtab;           /* The file's string table.  */
7977   unsigned long       strtab_size;      /* Size of string table.  */
7978 };
7979
7980 static const char *
7981 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7982                         bfd_vma fn, struct absaddr addr)
7983 {
7984   const char *procname;
7985   bfd_vma sym_offset;
7986
7987   if (addr.section == SHN_UNDEF)
7988     addr.offset = fn;
7989
7990   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7991                            aux->strtab_size, addr, &procname,
7992                            &sym_offset);
7993
7994   print_vma (fn, PREFIX_HEX);
7995
7996   if (procname)
7997     {
7998       fputs (" <", stdout);
7999       fputs (procname, stdout);
8000
8001       if (sym_offset)
8002         printf ("+0x%lx", (unsigned long) sym_offset);
8003       fputc ('>', stdout);
8004     }
8005
8006   return procname;
8007 }
8008
8009 static void
8010 arm_free_section (struct arm_section *arm_sec)
8011 {
8012   if (arm_sec->data != NULL)
8013     free (arm_sec->data);
8014
8015   if (arm_sec->rela != NULL)
8016     free (arm_sec->rela);
8017 }
8018
8019 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8020       cached section and install SEC instead.
8021    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8022       and return its valued in * WORDP, relocating if necessary.
8023    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8024       relocation's offset in ADDR.
8025    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8026       into the string table of the symbol associated with the reloc.  If no
8027       reloc was applied store -1 there.
8028    5) Return TRUE upon success, FALSE otherwise.  */
8029
8030 static bfd_boolean
8031 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8032                          struct arm_section *       arm_sec,
8033                          Elf_Internal_Shdr *        sec,
8034                          bfd_vma                    word_offset,
8035                          unsigned int *             wordp,
8036                          struct absaddr *           addr,
8037                          bfd_vma *                  sym_name)
8038 {
8039   Elf_Internal_Rela *rp;
8040   Elf_Internal_Sym *sym;
8041   const char * relname;
8042   unsigned int word;
8043   bfd_boolean wrapped;
8044
8045   if (sec == NULL || arm_sec == NULL)
8046     return FALSE;
8047
8048   addr->section = SHN_UNDEF;
8049   addr->offset = 0;
8050
8051   if (sym_name != NULL)
8052     *sym_name = (bfd_vma) -1;
8053
8054   /* If necessary, update the section cache.  */
8055   if (sec != arm_sec->sec)
8056     {
8057       Elf_Internal_Shdr *relsec;
8058
8059       arm_free_section (arm_sec);
8060
8061       arm_sec->sec = sec;
8062       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8063                                 sec->sh_size, _("unwind data"));
8064       arm_sec->rela = NULL;
8065       arm_sec->nrelas = 0;
8066
8067       for (relsec = section_headers;
8068            relsec < section_headers + elf_header.e_shnum;
8069            ++relsec)
8070         {
8071           if (relsec->sh_info >= elf_header.e_shnum
8072               || section_headers + relsec->sh_info != sec
8073               /* PR 15745: Check the section type as well.  */
8074               || (relsec->sh_type != SHT_REL
8075                   && relsec->sh_type != SHT_RELA))
8076             continue;
8077
8078           arm_sec->rel_type = relsec->sh_type;
8079           if (relsec->sh_type == SHT_REL)
8080             {
8081               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8082                                      relsec->sh_size,
8083                                      & arm_sec->rela, & arm_sec->nrelas))
8084                 return FALSE;
8085             }
8086           else /* relsec->sh_type == SHT_RELA */
8087             {
8088               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8089                                       relsec->sh_size,
8090                                       & arm_sec->rela, & arm_sec->nrelas))
8091                 return FALSE;
8092             }
8093           break;
8094         }
8095
8096       arm_sec->next_rela = arm_sec->rela;
8097     }
8098
8099   /* If there is no unwind data we can do nothing.  */
8100   if (arm_sec->data == NULL)
8101     return FALSE;
8102
8103   /* If the offset is invalid then fail.  */
8104   if (/* PR 21343 *//* PR 18879 */
8105       sec->sh_size < 4
8106       || word_offset > (sec->sh_size - 4)
8107       || ((bfd_signed_vma) word_offset) < 0)
8108     return FALSE;
8109
8110   /* Get the word at the required offset.  */
8111   word = byte_get (arm_sec->data + word_offset, 4);
8112
8113   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8114   if (arm_sec->rela == NULL)
8115     {
8116       * wordp = word;
8117       return TRUE;
8118     }
8119
8120   /* Look through the relocs to find the one that applies to the provided offset.  */
8121   wrapped = FALSE;
8122   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8123     {
8124       bfd_vma prelval, offset;
8125
8126       if (rp->r_offset > word_offset && !wrapped)
8127         {
8128           rp = arm_sec->rela;
8129           wrapped = TRUE;
8130         }
8131       if (rp->r_offset > word_offset)
8132         break;
8133
8134       if (rp->r_offset & 3)
8135         {
8136           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8137                 (unsigned long) rp->r_offset);
8138           continue;
8139         }
8140
8141       if (rp->r_offset < word_offset)
8142         continue;
8143
8144       /* PR 17531: file: 027-161405-0.004  */
8145       if (aux->symtab == NULL)
8146         continue;
8147
8148       if (arm_sec->rel_type == SHT_REL)
8149         {
8150           offset = word & 0x7fffffff;
8151           if (offset & 0x40000000)
8152             offset |= ~ (bfd_vma) 0x7fffffff;
8153         }
8154       else if (arm_sec->rel_type == SHT_RELA)
8155         offset = rp->r_addend;
8156       else
8157         {
8158           error (_("Unknown section relocation type %d encountered\n"),
8159                  arm_sec->rel_type);
8160           break;
8161         }
8162
8163       /* PR 17531 file: 027-1241568-0.004.  */
8164       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8165         {
8166           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8167                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8168           break;
8169         }
8170
8171       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8172       offset += sym->st_value;
8173       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8174
8175       /* Check that we are processing the expected reloc type.  */
8176       if (elf_header.e_machine == EM_ARM)
8177         {
8178           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8179           if (relname == NULL)
8180             {
8181               warn (_("Skipping unknown ARM relocation type: %d\n"),
8182                     (int) ELF32_R_TYPE (rp->r_info));
8183               continue;
8184             }
8185
8186           if (streq (relname, "R_ARM_NONE"))
8187               continue;
8188
8189           if (! streq (relname, "R_ARM_PREL31"))
8190             {
8191               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8192               continue;
8193             }
8194         }
8195       else if (elf_header.e_machine == EM_TI_C6000)
8196         {
8197           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8198           if (relname == NULL)
8199             {
8200               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8201                     (int) ELF32_R_TYPE (rp->r_info));
8202               continue;
8203             }
8204
8205           if (streq (relname, "R_C6000_NONE"))
8206             continue;
8207
8208           if (! streq (relname, "R_C6000_PREL31"))
8209             {
8210               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8211               continue;
8212             }
8213
8214           prelval >>= 1;
8215         }
8216       else
8217         {
8218           /* This function currently only supports ARM and TI unwinders.  */
8219           warn (_("Only TI and ARM unwinders are currently supported\n"));
8220           break;
8221         }
8222
8223       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8224       addr->section = sym->st_shndx;
8225       addr->offset = offset;
8226
8227       if (sym_name)
8228         * sym_name = sym->st_name;
8229       break;
8230     }
8231
8232   *wordp = word;
8233   arm_sec->next_rela = rp;
8234
8235   return TRUE;
8236 }
8237
8238 static const char *tic6x_unwind_regnames[16] =
8239 {
8240   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8241   "A14", "A13", "A12", "A11", "A10",
8242   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8243 };
8244
8245 static void
8246 decode_tic6x_unwind_regmask (unsigned int mask)
8247 {
8248   int i;
8249
8250   for (i = 12; mask; mask >>= 1, i--)
8251     {
8252       if (mask & 1)
8253         {
8254           fputs (tic6x_unwind_regnames[i], stdout);
8255           if (mask > 1)
8256             fputs (", ", stdout);
8257         }
8258     }
8259 }
8260
8261 #define ADVANCE                                                 \
8262   if (remaining == 0 && more_words)                             \
8263     {                                                           \
8264       data_offset += 4;                                         \
8265       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8266                                      data_offset, & word, & addr, NULL))        \
8267         return FALSE;                                           \
8268       remaining = 4;                                            \
8269       more_words--;                                             \
8270     }                                                           \
8271
8272 #define GET_OP(OP)                      \
8273   ADVANCE;                              \
8274   if (remaining)                        \
8275     {                                   \
8276       remaining--;                      \
8277       (OP) = word >> 24;                \
8278       word <<= 8;                       \
8279     }                                   \
8280   else                                  \
8281     {                                   \
8282       printf (_("[Truncated opcode]\n"));       \
8283       return FALSE;                     \
8284     }                                   \
8285   printf ("0x%02x ", OP)
8286
8287 static bfd_boolean
8288 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8289                             unsigned int               word,
8290                             unsigned int               remaining,
8291                             unsigned int               more_words,
8292                             bfd_vma                    data_offset,
8293                             Elf_Internal_Shdr *        data_sec,
8294                             struct arm_section *       data_arm_sec)
8295 {
8296   struct absaddr addr;
8297   bfd_boolean res = TRUE;
8298
8299   /* Decode the unwinding instructions.  */
8300   while (1)
8301     {
8302       unsigned int op, op2;
8303
8304       ADVANCE;
8305       if (remaining == 0)
8306         break;
8307       remaining--;
8308       op = word >> 24;
8309       word <<= 8;
8310
8311       printf ("  0x%02x ", op);
8312
8313       if ((op & 0xc0) == 0x00)
8314         {
8315           int offset = ((op & 0x3f) << 2) + 4;
8316
8317           printf ("     vsp = vsp + %d", offset);
8318         }
8319       else if ((op & 0xc0) == 0x40)
8320         {
8321           int offset = ((op & 0x3f) << 2) + 4;
8322
8323           printf ("     vsp = vsp - %d", offset);
8324         }
8325       else if ((op & 0xf0) == 0x80)
8326         {
8327           GET_OP (op2);
8328           if (op == 0x80 && op2 == 0)
8329             printf (_("Refuse to unwind"));
8330           else
8331             {
8332               unsigned int mask = ((op & 0x0f) << 8) | op2;
8333               bfd_boolean first = TRUE;
8334               int i;
8335
8336               printf ("pop {");
8337               for (i = 0; i < 12; i++)
8338                 if (mask & (1 << i))
8339                   {
8340                     if (first)
8341                       first = FALSE;
8342                     else
8343                       printf (", ");
8344                     printf ("r%d", 4 + i);
8345                   }
8346               printf ("}");
8347             }
8348         }
8349       else if ((op & 0xf0) == 0x90)
8350         {
8351           if (op == 0x9d || op == 0x9f)
8352             printf (_("     [Reserved]"));
8353           else
8354             printf ("     vsp = r%d", op & 0x0f);
8355         }
8356       else if ((op & 0xf0) == 0xa0)
8357         {
8358           int end = 4 + (op & 0x07);
8359           bfd_boolean first = TRUE;
8360           int i;
8361
8362           printf ("     pop {");
8363           for (i = 4; i <= end; i++)
8364             {
8365               if (first)
8366                 first = FALSE;
8367               else
8368                 printf (", ");
8369               printf ("r%d", i);
8370             }
8371           if (op & 0x08)
8372             {
8373               if (!first)
8374                 printf (", ");
8375               printf ("r14");
8376             }
8377           printf ("}");
8378         }
8379       else if (op == 0xb0)
8380         printf (_("     finish"));
8381       else if (op == 0xb1)
8382         {
8383           GET_OP (op2);
8384           if (op2 == 0 || (op2 & 0xf0) != 0)
8385             printf (_("[Spare]"));
8386           else
8387             {
8388               unsigned int mask = op2 & 0x0f;
8389               bfd_boolean first = TRUE;
8390               int i;
8391
8392               printf ("pop {");
8393               for (i = 0; i < 12; i++)
8394                 if (mask & (1 << i))
8395                   {
8396                     if (first)
8397                       first = FALSE;
8398                     else
8399                       printf (", ");
8400                     printf ("r%d", i);
8401                   }
8402               printf ("}");
8403             }
8404         }
8405       else if (op == 0xb2)
8406         {
8407           unsigned char buf[9];
8408           unsigned int i, len;
8409           unsigned long offset;
8410
8411           for (i = 0; i < sizeof (buf); i++)
8412             {
8413               GET_OP (buf[i]);
8414               if ((buf[i] & 0x80) == 0)
8415                 break;
8416             }
8417           if (i == sizeof (buf))
8418             {
8419               error (_("corrupt change to vsp"));
8420               res = FALSE;
8421             }
8422           else
8423             {
8424               offset = read_uleb128 (buf, &len, buf + i + 1);
8425               assert (len == i + 1);
8426               offset = offset * 4 + 0x204;
8427               printf ("vsp = vsp + %ld", offset);
8428             }
8429         }
8430       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8431         {
8432           unsigned int first, last;
8433
8434           GET_OP (op2);
8435           first = op2 >> 4;
8436           last = op2 & 0x0f;
8437           if (op == 0xc8)
8438             first = first + 16;
8439           printf ("pop {D%d", first);
8440           if (last)
8441             printf ("-D%d", first + last);
8442           printf ("}");
8443         }
8444       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8445         {
8446           unsigned int count = op & 0x07;
8447
8448           printf ("pop {D8");
8449           if (count)
8450             printf ("-D%d", 8 + count);
8451           printf ("}");
8452         }
8453       else if (op >= 0xc0 && op <= 0xc5)
8454         {
8455           unsigned int count = op & 0x07;
8456
8457           printf ("     pop {wR10");
8458           if (count)
8459             printf ("-wR%d", 10 + count);
8460           printf ("}");
8461         }
8462       else if (op == 0xc6)
8463         {
8464           unsigned int first, last;
8465
8466           GET_OP (op2);
8467           first = op2 >> 4;
8468           last = op2 & 0x0f;
8469           printf ("pop {wR%d", first);
8470           if (last)
8471             printf ("-wR%d", first + last);
8472           printf ("}");
8473         }
8474       else if (op == 0xc7)
8475         {
8476           GET_OP (op2);
8477           if (op2 == 0 || (op2 & 0xf0) != 0)
8478             printf (_("[Spare]"));
8479           else
8480             {
8481               unsigned int mask = op2 & 0x0f;
8482               bfd_boolean first = TRUE;
8483               int i;
8484
8485               printf ("pop {");
8486               for (i = 0; i < 4; i++)
8487                 if (mask & (1 << i))
8488                   {
8489                     if (first)
8490                       first = FALSE;
8491                     else
8492                       printf (", ");
8493                     printf ("wCGR%d", i);
8494                   }
8495               printf ("}");
8496             }
8497         }
8498       else
8499         {
8500           printf (_("     [unsupported opcode]"));
8501           res = FALSE;
8502         }
8503
8504       printf ("\n");
8505     }
8506
8507   return res;
8508 }
8509
8510 static bfd_boolean
8511 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8512                               unsigned int               word,
8513                               unsigned int               remaining,
8514                               unsigned int               more_words,
8515                               bfd_vma                    data_offset,
8516                               Elf_Internal_Shdr *        data_sec,
8517                               struct arm_section *       data_arm_sec)
8518 {
8519   struct absaddr addr;
8520
8521   /* Decode the unwinding instructions.  */
8522   while (1)
8523     {
8524       unsigned int op, op2;
8525
8526       ADVANCE;
8527       if (remaining == 0)
8528         break;
8529       remaining--;
8530       op = word >> 24;
8531       word <<= 8;
8532
8533       printf ("  0x%02x ", op);
8534
8535       if ((op & 0xc0) == 0x00)
8536         {
8537           int offset = ((op & 0x3f) << 3) + 8;
8538           printf ("     sp = sp + %d", offset);
8539         }
8540       else if ((op & 0xc0) == 0x80)
8541         {
8542           GET_OP (op2);
8543           if (op == 0x80 && op2 == 0)
8544             printf (_("Refuse to unwind"));
8545           else
8546             {
8547               unsigned int mask = ((op & 0x1f) << 8) | op2;
8548               if (op & 0x20)
8549                 printf ("pop compact {");
8550               else
8551                 printf ("pop {");
8552
8553               decode_tic6x_unwind_regmask (mask);
8554               printf("}");
8555             }
8556         }
8557       else if ((op & 0xf0) == 0xc0)
8558         {
8559           unsigned int reg;
8560           unsigned int nregs;
8561           unsigned int i;
8562           const char *name;
8563           struct
8564           {
8565             unsigned int offset;
8566             unsigned int reg;
8567           } regpos[16];
8568
8569           /* Scan entire instruction first so that GET_OP output is not
8570              interleaved with disassembly.  */
8571           nregs = 0;
8572           for (i = 0; nregs < (op & 0xf); i++)
8573             {
8574               GET_OP (op2);
8575               reg = op2 >> 4;
8576               if (reg != 0xf)
8577                 {
8578                   regpos[nregs].offset = i * 2;
8579                   regpos[nregs].reg = reg;
8580                   nregs++;
8581                 }
8582
8583               reg = op2 & 0xf;
8584               if (reg != 0xf)
8585                 {
8586                   regpos[nregs].offset = i * 2 + 1;
8587                   regpos[nregs].reg = reg;
8588                   nregs++;
8589                 }
8590             }
8591
8592           printf (_("pop frame {"));
8593           reg = nregs - 1;
8594           for (i = i * 2; i > 0; i--)
8595             {
8596               if (regpos[reg].offset == i - 1)
8597                 {
8598                   name = tic6x_unwind_regnames[regpos[reg].reg];
8599                   if (reg > 0)
8600                     reg--;
8601                 }
8602               else
8603                 name = _("[pad]");
8604
8605               fputs (name, stdout);
8606               if (i > 1)
8607                 printf (", ");
8608             }
8609
8610           printf ("}");
8611         }
8612       else if (op == 0xd0)
8613         printf ("     MOV FP, SP");
8614       else if (op == 0xd1)
8615         printf ("     __c6xabi_pop_rts");
8616       else if (op == 0xd2)
8617         {
8618           unsigned char buf[9];
8619           unsigned int i, len;
8620           unsigned long offset;
8621
8622           for (i = 0; i < sizeof (buf); i++)
8623             {
8624               GET_OP (buf[i]);
8625               if ((buf[i] & 0x80) == 0)
8626                 break;
8627             }
8628           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8629           if (i == sizeof (buf))
8630             {
8631               warn (_("Corrupt stack pointer adjustment detected\n"));
8632               return FALSE;
8633             }
8634
8635           offset = read_uleb128 (buf, &len, buf + i + 1);
8636           assert (len == i + 1);
8637           offset = offset * 8 + 0x408;
8638           printf (_("sp = sp + %ld"), offset);
8639         }
8640       else if ((op & 0xf0) == 0xe0)
8641         {
8642           if ((op & 0x0f) == 7)
8643             printf ("     RETURN");
8644           else
8645             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8646         }
8647       else
8648         {
8649           printf (_("     [unsupported opcode]"));
8650         }
8651       putchar ('\n');
8652     }
8653
8654   return TRUE;
8655 }
8656
8657 static bfd_vma
8658 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8659 {
8660   bfd_vma offset;
8661
8662   offset = word & 0x7fffffff;
8663   if (offset & 0x40000000)
8664     offset |= ~ (bfd_vma) 0x7fffffff;
8665
8666   if (elf_header.e_machine == EM_TI_C6000)
8667     offset <<= 1;
8668
8669   return offset + where;
8670 }
8671
8672 static bfd_boolean
8673 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8674                    unsigned int               word,
8675                    unsigned int               remaining,
8676                    bfd_vma                    data_offset,
8677                    Elf_Internal_Shdr *        data_sec,
8678                    struct arm_section *       data_arm_sec)
8679 {
8680   int per_index;
8681   unsigned int more_words = 0;
8682   struct absaddr addr;
8683   bfd_vma sym_name = (bfd_vma) -1;
8684   bfd_boolean res = FALSE;
8685
8686   if (remaining == 0)
8687     {
8688       /* Fetch the first word.
8689          Note - when decoding an object file the address extracted
8690          here will always be 0.  So we also pass in the sym_name
8691          parameter so that we can find the symbol associated with
8692          the personality routine.  */
8693       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8694                                      & word, & addr, & sym_name))
8695         return FALSE;
8696
8697       remaining = 4;
8698     }
8699
8700   if ((word & 0x80000000) == 0)
8701     {
8702       /* Expand prel31 for personality routine.  */
8703       bfd_vma fn;
8704       const char *procname;
8705
8706       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8707       printf (_("  Personality routine: "));
8708       if (fn == 0
8709           && addr.section == SHN_UNDEF && addr.offset == 0
8710           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8711         {
8712           procname = aux->strtab + sym_name;
8713           print_vma (fn, PREFIX_HEX);
8714           if (procname)
8715             {
8716               fputs (" <", stdout);
8717               fputs (procname, stdout);
8718               fputc ('>', stdout);
8719             }
8720         }
8721       else
8722         procname = arm_print_vma_and_name (aux, fn, addr);
8723       fputc ('\n', stdout);
8724
8725       /* The GCC personality routines use the standard compact
8726          encoding, starting with one byte giving the number of
8727          words.  */
8728       if (procname != NULL
8729           && (const_strneq (procname, "__gcc_personality_v0")
8730               || const_strneq (procname, "__gxx_personality_v0")
8731               || const_strneq (procname, "__gcj_personality_v0")
8732               || const_strneq (procname, "__gnu_objc_personality_v0")))
8733         {
8734           remaining = 0;
8735           more_words = 1;
8736           ADVANCE;
8737           if (!remaining)
8738             {
8739               printf (_("  [Truncated data]\n"));
8740               return FALSE;
8741             }
8742           more_words = word >> 24;
8743           word <<= 8;
8744           remaining--;
8745           per_index = -1;
8746         }
8747       else
8748         return TRUE;
8749     }
8750   else
8751     {
8752       /* ARM EHABI Section 6.3:
8753
8754          An exception-handling table entry for the compact model looks like:
8755
8756            31 30-28 27-24 23-0
8757            -- ----- ----- ----
8758             1   0   index Data for personalityRoutine[index]    */
8759
8760       if (elf_header.e_machine == EM_ARM
8761           && (word & 0x70000000))
8762         {
8763           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8764           res = FALSE;
8765         }
8766
8767       per_index = (word >> 24) & 0x7f;
8768       printf (_("  Compact model index: %d\n"), per_index);
8769       if (per_index == 0)
8770         {
8771           more_words = 0;
8772           word <<= 8;
8773           remaining--;
8774         }
8775       else if (per_index < 3)
8776         {
8777           more_words = (word >> 16) & 0xff;
8778           word <<= 16;
8779           remaining -= 2;
8780         }
8781     }
8782
8783   switch (elf_header.e_machine)
8784     {
8785     case EM_ARM:
8786       if (per_index < 3)
8787         {
8788           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8789                                             data_offset, data_sec, data_arm_sec))
8790             res = FALSE;
8791         }
8792       else
8793         {
8794           warn (_("Unknown ARM compact model index encountered\n"));
8795           printf (_("  [reserved]\n"));
8796           res = FALSE;
8797         }
8798       break;
8799
8800     case EM_TI_C6000:
8801       if (per_index < 3)
8802         {
8803           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8804                                               data_offset, data_sec, data_arm_sec))
8805             res = FALSE;
8806         }
8807       else if (per_index < 5)
8808         {
8809           if (((word >> 17) & 0x7f) == 0x7f)
8810             printf (_("  Restore stack from frame pointer\n"));
8811           else
8812             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8813           printf (_("  Registers restored: "));
8814           if (per_index == 4)
8815             printf (" (compact) ");
8816           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8817           putchar ('\n');
8818           printf (_("  Return register: %s\n"),
8819                   tic6x_unwind_regnames[word & 0xf]);
8820         }
8821       else
8822         printf (_("  [reserved (%d)]\n"), per_index);
8823       break;
8824
8825     default:
8826       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8827              elf_header.e_machine);
8828       res = FALSE;
8829     }
8830
8831   /* Decode the descriptors.  Not implemented.  */
8832
8833   return res;
8834 }
8835
8836 static bfd_boolean
8837 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8838 {
8839   struct arm_section exidx_arm_sec, extab_arm_sec;
8840   unsigned int i, exidx_len;
8841   unsigned long j, nfuns;
8842   bfd_boolean res = TRUE;
8843
8844   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8845   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8846   exidx_len = exidx_sec->sh_size / 8;
8847
8848   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8849   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8850     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8851       aux->funtab[nfuns++] = aux->symtab[j];
8852   aux->nfuns = nfuns;
8853   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8854
8855   for (i = 0; i < exidx_len; i++)
8856     {
8857       unsigned int exidx_fn, exidx_entry;
8858       struct absaddr fn_addr, entry_addr;
8859       bfd_vma fn;
8860
8861       fputc ('\n', stdout);
8862
8863       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8864                                      8 * i, & exidx_fn, & fn_addr, NULL)
8865           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8866                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8867         {
8868           free (aux->funtab);
8869           arm_free_section (& exidx_arm_sec);
8870           arm_free_section (& extab_arm_sec);
8871           return FALSE;
8872         }
8873
8874       /* ARM EHABI, Section 5:
8875          An index table entry consists of 2 words.
8876          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8877       if (exidx_fn & 0x80000000)
8878         {
8879           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8880           res = FALSE;
8881         }
8882
8883       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8884
8885       arm_print_vma_and_name (aux, fn, fn_addr);
8886       fputs (": ", stdout);
8887
8888       if (exidx_entry == 1)
8889         {
8890           print_vma (exidx_entry, PREFIX_HEX);
8891           fputs (" [cantunwind]\n", stdout);
8892         }
8893       else if (exidx_entry & 0x80000000)
8894         {
8895           print_vma (exidx_entry, PREFIX_HEX);
8896           fputc ('\n', stdout);
8897           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8898         }
8899       else
8900         {
8901           bfd_vma table, table_offset = 0;
8902           Elf_Internal_Shdr *table_sec;
8903
8904           fputs ("@", stdout);
8905           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8906           print_vma (table, PREFIX_HEX);
8907           printf ("\n");
8908
8909           /* Locate the matching .ARM.extab.  */
8910           if (entry_addr.section != SHN_UNDEF
8911               && entry_addr.section < elf_header.e_shnum)
8912             {
8913               table_sec = section_headers + entry_addr.section;
8914               table_offset = entry_addr.offset;
8915               /* PR 18879 */
8916               if (table_offset > table_sec->sh_size
8917                   || ((bfd_signed_vma) table_offset) < 0)
8918                 {
8919                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8920                         (unsigned long) table_offset,
8921                         printable_section_name (table_sec));
8922                   res = FALSE;
8923                   continue;
8924                 }
8925             }
8926           else
8927             {
8928               table_sec = find_section_by_address (table);
8929               if (table_sec != NULL)
8930                 table_offset = table - table_sec->sh_addr;
8931             }
8932
8933           if (table_sec == NULL)
8934             {
8935               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8936                     (unsigned long) table);
8937               res = FALSE;
8938               continue;
8939             }
8940
8941           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8942                                    &extab_arm_sec))
8943             res = FALSE;
8944         }
8945     }
8946
8947   printf ("\n");
8948
8949   free (aux->funtab);
8950   arm_free_section (&exidx_arm_sec);
8951   arm_free_section (&extab_arm_sec);
8952
8953   return res;
8954 }
8955
8956 /* Used for both ARM and C6X unwinding tables.  */
8957
8958 static bfd_boolean
8959 arm_process_unwind (FILE *file)
8960 {
8961   struct arm_unw_aux_info aux;
8962   Elf_Internal_Shdr *unwsec = NULL;
8963   Elf_Internal_Shdr *strsec;
8964   Elf_Internal_Shdr *sec;
8965   unsigned long i;
8966   unsigned int sec_type;
8967   bfd_boolean res = TRUE;
8968
8969   switch (elf_header.e_machine)
8970     {
8971     case EM_ARM:
8972       sec_type = SHT_ARM_EXIDX;
8973       break;
8974
8975     case EM_TI_C6000:
8976       sec_type = SHT_C6000_UNWIND;
8977       break;
8978
8979     default:
8980       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8981              elf_header.e_machine);
8982       return FALSE;
8983     }
8984
8985   if (string_table == NULL)
8986     return FALSE;
8987
8988   memset (& aux, 0, sizeof (aux));
8989   aux.file = file;
8990
8991   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8992     {
8993       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8994         {
8995           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8996
8997           strsec = section_headers + sec->sh_link;
8998
8999           /* PR binutils/17531 file: 011-12666-0.004.  */
9000           if (aux.strtab != NULL)
9001             {
9002               error (_("Multiple string tables found in file.\n"));
9003               free (aux.strtab);
9004               res = FALSE;
9005             }
9006           aux.strtab = get_data (NULL, file, strsec->sh_offset,
9007                                  1, strsec->sh_size, _("string table"));
9008           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9009         }
9010       else if (sec->sh_type == sec_type)
9011         unwsec = sec;
9012     }
9013
9014   if (unwsec == NULL)
9015     printf (_("\nThere are no unwind sections in this file.\n"));
9016   else
9017     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9018       {
9019         if (sec->sh_type == sec_type)
9020           {
9021             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9022                     printable_section_name (sec),
9023                     (unsigned long) sec->sh_offset,
9024                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9025
9026             if (! dump_arm_unwind (&aux, sec))
9027               res = FALSE;
9028           }
9029       }
9030
9031   if (aux.symtab)
9032     free (aux.symtab);
9033   if (aux.strtab)
9034     free ((char *) aux.strtab);
9035
9036   return res;
9037 }
9038
9039 static bfd_boolean
9040 process_unwind (FILE * file)
9041 {
9042   struct unwind_handler
9043   {
9044     unsigned int machtype;
9045     bfd_boolean (* handler)(FILE *);
9046   } handlers[] =
9047   {
9048     { EM_ARM, arm_process_unwind },
9049     { EM_IA_64, ia64_process_unwind },
9050     { EM_PARISC, hppa_process_unwind },
9051     { EM_TI_C6000, arm_process_unwind },
9052     { 0, NULL }
9053   };
9054   int i;
9055
9056   if (!do_unwind)
9057     return TRUE;
9058
9059   for (i = 0; handlers[i].handler != NULL; i++)
9060     if (elf_header.e_machine == handlers[i].machtype)
9061       return handlers[i].handler (file);
9062
9063   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9064           get_machine_name (elf_header.e_machine));
9065   return TRUE;
9066 }
9067
9068 static void
9069 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9070 {
9071   switch (entry->d_tag)
9072     {
9073     case DT_MIPS_FLAGS:
9074       if (entry->d_un.d_val == 0)
9075         printf (_("NONE"));
9076       else
9077         {
9078           static const char * opts[] =
9079           {
9080             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9081             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9082             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9083             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9084             "RLD_ORDER_SAFE"
9085           };
9086           unsigned int cnt;
9087           bfd_boolean first = TRUE;
9088
9089           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9090             if (entry->d_un.d_val & (1 << cnt))
9091               {
9092                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9093                 first = FALSE;
9094               }
9095         }
9096       break;
9097
9098     case DT_MIPS_IVERSION:
9099       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9100         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9101       else
9102         {
9103           char buf[40];
9104           sprintf_vma (buf, entry->d_un.d_ptr);
9105           /* Note: coded this way so that there is a single string for translation.  */
9106           printf (_("<corrupt: %s>"), buf);
9107         }
9108       break;
9109
9110     case DT_MIPS_TIME_STAMP:
9111       {
9112         char timebuf[128];
9113         struct tm * tmp;
9114         time_t atime = entry->d_un.d_val;
9115
9116         tmp = gmtime (&atime);
9117         /* PR 17531: file: 6accc532.  */
9118         if (tmp == NULL)
9119           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9120         else
9121           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9122                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9123                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9124         printf (_("Time Stamp: %s"), timebuf);
9125       }
9126       break;
9127
9128     case DT_MIPS_RLD_VERSION:
9129     case DT_MIPS_LOCAL_GOTNO:
9130     case DT_MIPS_CONFLICTNO:
9131     case DT_MIPS_LIBLISTNO:
9132     case DT_MIPS_SYMTABNO:
9133     case DT_MIPS_UNREFEXTNO:
9134     case DT_MIPS_HIPAGENO:
9135     case DT_MIPS_DELTA_CLASS_NO:
9136     case DT_MIPS_DELTA_INSTANCE_NO:
9137     case DT_MIPS_DELTA_RELOC_NO:
9138     case DT_MIPS_DELTA_SYM_NO:
9139     case DT_MIPS_DELTA_CLASSSYM_NO:
9140     case DT_MIPS_COMPACT_SIZE:
9141       print_vma (entry->d_un.d_val, DEC);
9142       break;
9143
9144     default:
9145       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9146     }
9147     putchar ('\n');
9148 }
9149
9150 static void
9151 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9152 {
9153   switch (entry->d_tag)
9154     {
9155     case DT_HP_DLD_FLAGS:
9156       {
9157         static struct
9158         {
9159           long int bit;
9160           const char * str;
9161         }
9162         flags[] =
9163         {
9164           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9165           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9166           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9167           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9168           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9169           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9170           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9171           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9172           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9173           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9174           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9175           { DT_HP_GST, "HP_GST" },
9176           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9177           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9178           { DT_HP_NODELETE, "HP_NODELETE" },
9179           { DT_HP_GROUP, "HP_GROUP" },
9180           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9181         };
9182         bfd_boolean first = TRUE;
9183         size_t cnt;
9184         bfd_vma val = entry->d_un.d_val;
9185
9186         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9187           if (val & flags[cnt].bit)
9188             {
9189               if (! first)
9190                 putchar (' ');
9191               fputs (flags[cnt].str, stdout);
9192               first = FALSE;
9193               val ^= flags[cnt].bit;
9194             }
9195
9196         if (val != 0 || first)
9197           {
9198             if (! first)
9199               putchar (' ');
9200             print_vma (val, HEX);
9201           }
9202       }
9203       break;
9204
9205     default:
9206       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9207       break;
9208     }
9209   putchar ('\n');
9210 }
9211
9212 #ifdef BFD64
9213
9214 /* VMS vs Unix time offset and factor.  */
9215
9216 #define VMS_EPOCH_OFFSET 35067168000000000LL
9217 #define VMS_GRANULARITY_FACTOR 10000000
9218
9219 /* Display a VMS time in a human readable format.  */
9220
9221 static void
9222 print_vms_time (bfd_int64_t vmstime)
9223 {
9224   struct tm *tm;
9225   time_t unxtime;
9226
9227   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9228   tm = gmtime (&unxtime);
9229   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9230           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9231           tm->tm_hour, tm->tm_min, tm->tm_sec);
9232 }
9233 #endif /* BFD64 */
9234
9235 static void
9236 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9237 {
9238   switch (entry->d_tag)
9239     {
9240     case DT_IA_64_PLT_RESERVE:
9241       /* First 3 slots reserved.  */
9242       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9243       printf (" -- ");
9244       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9245       break;
9246
9247     case DT_IA_64_VMS_LINKTIME:
9248 #ifdef BFD64
9249       print_vms_time (entry->d_un.d_val);
9250 #endif
9251       break;
9252
9253     case DT_IA_64_VMS_LNKFLAGS:
9254       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9255       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9256         printf (" CALL_DEBUG");
9257       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9258         printf (" NOP0BUFS");
9259       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9260         printf (" P0IMAGE");
9261       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9262         printf (" MKTHREADS");
9263       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9264         printf (" UPCALLS");
9265       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9266         printf (" IMGSTA");
9267       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9268         printf (" INITIALIZE");
9269       if (entry->d_un.d_val & VMS_LF_MAIN)
9270         printf (" MAIN");
9271       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9272         printf (" EXE_INIT");
9273       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9274         printf (" TBK_IN_IMG");
9275       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9276         printf (" DBG_IN_IMG");
9277       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9278         printf (" TBK_IN_DSF");
9279       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9280         printf (" DBG_IN_DSF");
9281       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9282         printf (" SIGNATURES");
9283       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9284         printf (" REL_SEG_OFF");
9285       break;
9286
9287     default:
9288       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9289       break;
9290     }
9291   putchar ('\n');
9292 }
9293
9294 static bfd_boolean
9295 get_32bit_dynamic_section (FILE * file)
9296 {
9297   Elf32_External_Dyn * edyn;
9298   Elf32_External_Dyn * ext;
9299   Elf_Internal_Dyn * entry;
9300
9301   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9302                                           dynamic_size, _("dynamic section"));
9303   if (!edyn)
9304     return FALSE;
9305
9306   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9307      might not have the luxury of section headers.  Look for the DT_NULL
9308      terminator to determine the number of entries.  */
9309   for (ext = edyn, dynamic_nent = 0;
9310        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9311        ext++)
9312     {
9313       dynamic_nent++;
9314       if (BYTE_GET (ext->d_tag) == DT_NULL)
9315         break;
9316     }
9317
9318   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9319                                                   sizeof (* entry));
9320   if (dynamic_section == NULL)
9321     {
9322       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9323              (unsigned long) dynamic_nent);
9324       free (edyn);
9325       return FALSE;
9326     }
9327
9328   for (ext = edyn, entry = dynamic_section;
9329        entry < dynamic_section + dynamic_nent;
9330        ext++, entry++)
9331     {
9332       entry->d_tag      = BYTE_GET (ext->d_tag);
9333       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9334     }
9335
9336   free (edyn);
9337
9338   return TRUE;
9339 }
9340
9341 static bfd_boolean
9342 get_64bit_dynamic_section (FILE * file)
9343 {
9344   Elf64_External_Dyn * edyn;
9345   Elf64_External_Dyn * ext;
9346   Elf_Internal_Dyn * entry;
9347
9348   /* Read in the data.  */
9349   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9350                                           dynamic_size, _("dynamic section"));
9351   if (!edyn)
9352     return FALSE;
9353
9354   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9355      might not have the luxury of section headers.  Look for the DT_NULL
9356      terminator to determine the number of entries.  */
9357   for (ext = edyn, dynamic_nent = 0;
9358        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9359        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9360        ext++)
9361     {
9362       dynamic_nent++;
9363       if (BYTE_GET (ext->d_tag) == DT_NULL)
9364         break;
9365     }
9366
9367   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9368                                                   sizeof (* entry));
9369   if (dynamic_section == NULL)
9370     {
9371       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9372              (unsigned long) dynamic_nent);
9373       free (edyn);
9374       return FALSE;
9375     }
9376
9377   /* Convert from external to internal formats.  */
9378   for (ext = edyn, entry = dynamic_section;
9379        entry < dynamic_section + dynamic_nent;
9380        ext++, entry++)
9381     {
9382       entry->d_tag      = BYTE_GET (ext->d_tag);
9383       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9384     }
9385
9386   free (edyn);
9387
9388   return TRUE;
9389 }
9390
9391 static void
9392 print_dynamic_flags (bfd_vma flags)
9393 {
9394   bfd_boolean first = TRUE;
9395
9396   while (flags)
9397     {
9398       bfd_vma flag;
9399
9400       flag = flags & - flags;
9401       flags &= ~ flag;
9402
9403       if (first)
9404         first = FALSE;
9405       else
9406         putc (' ', stdout);
9407
9408       switch (flag)
9409         {
9410         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9411         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9412         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9413         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9414         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9415         default:                fputs (_("unknown"), stdout); break;
9416         }
9417     }
9418   puts ("");
9419 }
9420
9421 /* Parse and display the contents of the dynamic section.  */
9422
9423 static bfd_boolean
9424 process_dynamic_section (FILE * file)
9425 {
9426   Elf_Internal_Dyn * entry;
9427
9428   if (dynamic_size == 0)
9429     {
9430       if (do_dynamic)
9431         printf (_("\nThere is no dynamic section in this file.\n"));
9432
9433       return TRUE;
9434     }
9435
9436   if (is_32bit_elf)
9437     {
9438       if (! get_32bit_dynamic_section (file))
9439         return FALSE;
9440     }
9441   else
9442     {
9443       if (! get_64bit_dynamic_section (file))
9444         return FALSE;
9445     }
9446
9447   /* Find the appropriate symbol table.  */
9448   if (dynamic_symbols == NULL)
9449     {
9450       for (entry = dynamic_section;
9451            entry < dynamic_section + dynamic_nent;
9452            ++entry)
9453         {
9454           Elf_Internal_Shdr section;
9455
9456           if (entry->d_tag != DT_SYMTAB)
9457             continue;
9458
9459           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9460
9461           /* Since we do not know how big the symbol table is,
9462              we default to reading in the entire file (!) and
9463              processing that.  This is overkill, I know, but it
9464              should work.  */
9465           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9466           if ((bfd_size_type) section.sh_offset > current_file_size)
9467             {
9468               /* See PR 21379 for a reproducer.  */
9469               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9470               return FALSE;
9471             }
9472
9473           if (archive_file_offset != 0)
9474             section.sh_size = archive_file_size - section.sh_offset;
9475           else
9476             {
9477               if (fseek (file, 0, SEEK_END))
9478                 error (_("Unable to seek to end of file!\n"));
9479
9480               section.sh_size = ftell (file) - section.sh_offset;
9481             }
9482
9483           if (is_32bit_elf)
9484             section.sh_entsize = sizeof (Elf32_External_Sym);
9485           else
9486             section.sh_entsize = sizeof (Elf64_External_Sym);
9487           section.sh_name = string_table_length;
9488
9489           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9490           if (num_dynamic_syms < 1)
9491             {
9492               error (_("Unable to determine the number of symbols to load\n"));
9493               continue;
9494             }
9495         }
9496     }
9497
9498   /* Similarly find a string table.  */
9499   if (dynamic_strings == NULL)
9500     {
9501       for (entry = dynamic_section;
9502            entry < dynamic_section + dynamic_nent;
9503            ++entry)
9504         {
9505           unsigned long offset;
9506           long str_tab_len;
9507
9508           if (entry->d_tag != DT_STRTAB)
9509             continue;
9510
9511           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9512
9513           /* Since we do not know how big the string table is,
9514              we default to reading in the entire file (!) and
9515              processing that.  This is overkill, I know, but it
9516              should work.  */
9517
9518           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9519
9520           if (archive_file_offset != 0)
9521             str_tab_len = archive_file_size - offset;
9522           else
9523             {
9524               if (fseek (file, 0, SEEK_END))
9525                 error (_("Unable to seek to end of file\n"));
9526               str_tab_len = ftell (file) - offset;
9527             }
9528
9529           if (str_tab_len < 1)
9530             {
9531               error
9532                 (_("Unable to determine the length of the dynamic string table\n"));
9533               continue;
9534             }
9535
9536           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9537                                                str_tab_len,
9538                                                _("dynamic string table"));
9539           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9540           break;
9541         }
9542     }
9543
9544   /* And find the syminfo section if available.  */
9545   if (dynamic_syminfo == NULL)
9546     {
9547       unsigned long syminsz = 0;
9548
9549       for (entry = dynamic_section;
9550            entry < dynamic_section + dynamic_nent;
9551            ++entry)
9552         {
9553           if (entry->d_tag == DT_SYMINENT)
9554             {
9555               /* Note: these braces are necessary to avoid a syntax
9556                  error from the SunOS4 C compiler.  */
9557               /* PR binutils/17531: A corrupt file can trigger this test.
9558                  So do not use an assert, instead generate an error message.  */
9559               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9560                 error (_("Bad value (%d) for SYMINENT entry\n"),
9561                        (int) entry->d_un.d_val);
9562             }
9563           else if (entry->d_tag == DT_SYMINSZ)
9564             syminsz = entry->d_un.d_val;
9565           else if (entry->d_tag == DT_SYMINFO)
9566             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9567                                                       syminsz);
9568         }
9569
9570       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9571         {
9572           Elf_External_Syminfo * extsyminfo;
9573           Elf_External_Syminfo * extsym;
9574           Elf_Internal_Syminfo * syminfo;
9575
9576           /* There is a syminfo section.  Read the data.  */
9577           extsyminfo = (Elf_External_Syminfo *)
9578               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9579                         _("symbol information"));
9580           if (!extsyminfo)
9581             return FALSE;
9582
9583           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9584           if (dynamic_syminfo == NULL)
9585             {
9586               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9587                      (unsigned long) syminsz);
9588               return FALSE;
9589             }
9590
9591           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9592           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9593                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9594                ++syminfo, ++extsym)
9595             {
9596               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9597               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9598             }
9599
9600           free (extsyminfo);
9601         }
9602     }
9603
9604   if (do_dynamic && dynamic_addr)
9605     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9606             dynamic_addr, (unsigned long) dynamic_nent);
9607   if (do_dynamic)
9608     printf (_("  Tag        Type                         Name/Value\n"));
9609
9610   for (entry = dynamic_section;
9611        entry < dynamic_section + dynamic_nent;
9612        entry++)
9613     {
9614       if (do_dynamic)
9615         {
9616           const char * dtype;
9617
9618           putchar (' ');
9619           print_vma (entry->d_tag, FULL_HEX);
9620           dtype = get_dynamic_type (entry->d_tag);
9621           printf (" (%s)%*s", dtype,
9622                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9623         }
9624
9625       switch (entry->d_tag)
9626         {
9627         case DT_FLAGS:
9628           if (do_dynamic)
9629             print_dynamic_flags (entry->d_un.d_val);
9630           break;
9631
9632         case DT_AUXILIARY:
9633         case DT_FILTER:
9634         case DT_CONFIG:
9635         case DT_DEPAUDIT:
9636         case DT_AUDIT:
9637           if (do_dynamic)
9638             {
9639               switch (entry->d_tag)
9640                 {
9641                 case DT_AUXILIARY:
9642                   printf (_("Auxiliary library"));
9643                   break;
9644
9645                 case DT_FILTER:
9646                   printf (_("Filter library"));
9647                   break;
9648
9649                 case DT_CONFIG:
9650                   printf (_("Configuration file"));
9651                   break;
9652
9653                 case DT_DEPAUDIT:
9654                   printf (_("Dependency audit library"));
9655                   break;
9656
9657                 case DT_AUDIT:
9658                   printf (_("Audit library"));
9659                   break;
9660                 }
9661
9662               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9663                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9664               else
9665                 {
9666                   printf (": ");
9667                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9668                   putchar ('\n');
9669                 }
9670             }
9671           break;
9672
9673         case DT_FEATURE:
9674           if (do_dynamic)
9675             {
9676               printf (_("Flags:"));
9677
9678               if (entry->d_un.d_val == 0)
9679                 printf (_(" None\n"));
9680               else
9681                 {
9682                   unsigned long int val = entry->d_un.d_val;
9683
9684                   if (val & DTF_1_PARINIT)
9685                     {
9686                       printf (" PARINIT");
9687                       val ^= DTF_1_PARINIT;
9688                     }
9689                   if (val & DTF_1_CONFEXP)
9690                     {
9691                       printf (" CONFEXP");
9692                       val ^= DTF_1_CONFEXP;
9693                     }
9694                   if (val != 0)
9695                     printf (" %lx", val);
9696                   puts ("");
9697                 }
9698             }
9699           break;
9700
9701         case DT_POSFLAG_1:
9702           if (do_dynamic)
9703             {
9704               printf (_("Flags:"));
9705
9706               if (entry->d_un.d_val == 0)
9707                 printf (_(" None\n"));
9708               else
9709                 {
9710                   unsigned long int val = entry->d_un.d_val;
9711
9712                   if (val & DF_P1_LAZYLOAD)
9713                     {
9714                       printf (" LAZYLOAD");
9715                       val ^= DF_P1_LAZYLOAD;
9716                     }
9717                   if (val & DF_P1_GROUPPERM)
9718                     {
9719                       printf (" GROUPPERM");
9720                       val ^= DF_P1_GROUPPERM;
9721                     }
9722                   if (val != 0)
9723                     printf (" %lx", val);
9724                   puts ("");
9725                 }
9726             }
9727           break;
9728
9729         case DT_FLAGS_1:
9730           if (do_dynamic)
9731             {
9732               printf (_("Flags:"));
9733               if (entry->d_un.d_val == 0)
9734                 printf (_(" None\n"));
9735               else
9736                 {
9737                   unsigned long int val = entry->d_un.d_val;
9738
9739                   if (val & DF_1_NOW)
9740                     {
9741                       printf (" NOW");
9742                       val ^= DF_1_NOW;
9743                     }
9744                   if (val & DF_1_GLOBAL)
9745                     {
9746                       printf (" GLOBAL");
9747                       val ^= DF_1_GLOBAL;
9748                     }
9749                   if (val & DF_1_GROUP)
9750                     {
9751                       printf (" GROUP");
9752                       val ^= DF_1_GROUP;
9753                     }
9754                   if (val & DF_1_NODELETE)
9755                     {
9756                       printf (" NODELETE");
9757                       val ^= DF_1_NODELETE;
9758                     }
9759                   if (val & DF_1_LOADFLTR)
9760                     {
9761                       printf (" LOADFLTR");
9762                       val ^= DF_1_LOADFLTR;
9763                     }
9764                   if (val & DF_1_INITFIRST)
9765                     {
9766                       printf (" INITFIRST");
9767                       val ^= DF_1_INITFIRST;
9768                     }
9769                   if (val & DF_1_NOOPEN)
9770                     {
9771                       printf (" NOOPEN");
9772                       val ^= DF_1_NOOPEN;
9773                     }
9774                   if (val & DF_1_ORIGIN)
9775                     {
9776                       printf (" ORIGIN");
9777                       val ^= DF_1_ORIGIN;
9778                     }
9779                   if (val & DF_1_DIRECT)
9780                     {
9781                       printf (" DIRECT");
9782                       val ^= DF_1_DIRECT;
9783                     }
9784                   if (val & DF_1_TRANS)
9785                     {
9786                       printf (" TRANS");
9787                       val ^= DF_1_TRANS;
9788                     }
9789                   if (val & DF_1_INTERPOSE)
9790                     {
9791                       printf (" INTERPOSE");
9792                       val ^= DF_1_INTERPOSE;
9793                     }
9794                   if (val & DF_1_NODEFLIB)
9795                     {
9796                       printf (" NODEFLIB");
9797                       val ^= DF_1_NODEFLIB;
9798                     }
9799                   if (val & DF_1_NODUMP)
9800                     {
9801                       printf (" NODUMP");
9802                       val ^= DF_1_NODUMP;
9803                     }
9804                   if (val & DF_1_CONFALT)
9805                     {
9806                       printf (" CONFALT");
9807                       val ^= DF_1_CONFALT;
9808                     }
9809                   if (val & DF_1_ENDFILTEE)
9810                     {
9811                       printf (" ENDFILTEE");
9812                       val ^= DF_1_ENDFILTEE;
9813                     }
9814                   if (val & DF_1_DISPRELDNE)
9815                     {
9816                       printf (" DISPRELDNE");
9817                       val ^= DF_1_DISPRELDNE;
9818                     }
9819                   if (val & DF_1_DISPRELPND)
9820                     {
9821                       printf (" DISPRELPND");
9822                       val ^= DF_1_DISPRELPND;
9823                     }
9824                   if (val & DF_1_NODIRECT)
9825                     {
9826                       printf (" NODIRECT");
9827                       val ^= DF_1_NODIRECT;
9828                     }
9829                   if (val & DF_1_IGNMULDEF)
9830                     {
9831                       printf (" IGNMULDEF");
9832                       val ^= DF_1_IGNMULDEF;
9833                     }
9834                   if (val & DF_1_NOKSYMS)
9835                     {
9836                       printf (" NOKSYMS");
9837                       val ^= DF_1_NOKSYMS;
9838                     }
9839                   if (val & DF_1_NOHDR)
9840                     {
9841                       printf (" NOHDR");
9842                       val ^= DF_1_NOHDR;
9843                     }
9844                   if (val & DF_1_EDITED)
9845                     {
9846                       printf (" EDITED");
9847                       val ^= DF_1_EDITED;
9848                     }
9849                   if (val & DF_1_NORELOC)
9850                     {
9851                       printf (" NORELOC");
9852                       val ^= DF_1_NORELOC;
9853                     }
9854                   if (val & DF_1_SYMINTPOSE)
9855                     {
9856                       printf (" SYMINTPOSE");
9857                       val ^= DF_1_SYMINTPOSE;
9858                     }
9859                   if (val & DF_1_GLOBAUDIT)
9860                     {
9861                       printf (" GLOBAUDIT");
9862                       val ^= DF_1_GLOBAUDIT;
9863                     }
9864                   if (val & DF_1_SINGLETON)
9865                     {
9866                       printf (" SINGLETON");
9867                       val ^= DF_1_SINGLETON;
9868                     }
9869                   if (val & DF_1_STUB)
9870                     {
9871                       printf (" STUB");
9872                       val ^= DF_1_STUB;
9873                     }
9874                   if (val & DF_1_PIE)
9875                     {
9876                       printf (" PIE");
9877                       val ^= DF_1_PIE;
9878                     }
9879                   if (val != 0)
9880                     printf (" %lx", val);
9881                   puts ("");
9882                 }
9883             }
9884           break;
9885
9886         case DT_PLTREL:
9887           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9888           if (do_dynamic)
9889             puts (get_dynamic_type (entry->d_un.d_val));
9890           break;
9891
9892         case DT_NULL    :
9893         case DT_NEEDED  :
9894         case DT_PLTGOT  :
9895         case DT_HASH    :
9896         case DT_STRTAB  :
9897         case DT_SYMTAB  :
9898         case DT_RELA    :
9899         case DT_INIT    :
9900         case DT_FINI    :
9901         case DT_SONAME  :
9902         case DT_RPATH   :
9903         case DT_SYMBOLIC:
9904         case DT_REL     :
9905         case DT_DEBUG   :
9906         case DT_TEXTREL :
9907         case DT_JMPREL  :
9908         case DT_RUNPATH :
9909           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9910
9911           if (do_dynamic)
9912             {
9913               char * name;
9914
9915               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9916                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9917               else
9918                 name = NULL;
9919
9920               if (name)
9921                 {
9922                   switch (entry->d_tag)
9923                     {
9924                     case DT_NEEDED:
9925                       printf (_("Shared library: [%s]"), name);
9926
9927                       if (streq (name, program_interpreter))
9928                         printf (_(" program interpreter"));
9929                       break;
9930
9931                     case DT_SONAME:
9932                       printf (_("Library soname: [%s]"), name);
9933                       break;
9934
9935                     case DT_RPATH:
9936                       printf (_("Library rpath: [%s]"), name);
9937                       break;
9938
9939                     case DT_RUNPATH:
9940                       printf (_("Library runpath: [%s]"), name);
9941                       break;
9942
9943                     default:
9944                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9945                       break;
9946                     }
9947                 }
9948               else
9949                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9950
9951               putchar ('\n');
9952             }
9953           break;
9954
9955         case DT_PLTRELSZ:
9956         case DT_RELASZ  :
9957         case DT_STRSZ   :
9958         case DT_RELSZ   :
9959         case DT_RELAENT :
9960         case DT_SYMENT  :
9961         case DT_RELENT  :
9962           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9963           /* Fall through.  */
9964         case DT_PLTPADSZ:
9965         case DT_MOVEENT :
9966         case DT_MOVESZ  :
9967         case DT_INIT_ARRAYSZ:
9968         case DT_FINI_ARRAYSZ:
9969         case DT_GNU_CONFLICTSZ:
9970         case DT_GNU_LIBLISTSZ:
9971           if (do_dynamic)
9972             {
9973               print_vma (entry->d_un.d_val, UNSIGNED);
9974               printf (_(" (bytes)\n"));
9975             }
9976           break;
9977
9978         case DT_VERDEFNUM:
9979         case DT_VERNEEDNUM:
9980         case DT_RELACOUNT:
9981         case DT_RELCOUNT:
9982           if (do_dynamic)
9983             {
9984               print_vma (entry->d_un.d_val, UNSIGNED);
9985               putchar ('\n');
9986             }
9987           break;
9988
9989         case DT_SYMINSZ:
9990         case DT_SYMINENT:
9991         case DT_SYMINFO:
9992         case DT_USED:
9993         case DT_INIT_ARRAY:
9994         case DT_FINI_ARRAY:
9995           if (do_dynamic)
9996             {
9997               if (entry->d_tag == DT_USED
9998                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9999                 {
10000                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10001
10002                   if (*name)
10003                     {
10004                       printf (_("Not needed object: [%s]\n"), name);
10005                       break;
10006                     }
10007                 }
10008
10009               print_vma (entry->d_un.d_val, PREFIX_HEX);
10010               putchar ('\n');
10011             }
10012           break;
10013
10014         case DT_BIND_NOW:
10015           /* The value of this entry is ignored.  */
10016           if (do_dynamic)
10017             putchar ('\n');
10018           break;
10019
10020         case DT_GNU_PRELINKED:
10021           if (do_dynamic)
10022             {
10023               struct tm * tmp;
10024               time_t atime = entry->d_un.d_val;
10025
10026               tmp = gmtime (&atime);
10027               /* PR 17533 file: 041-1244816-0.004.  */
10028               if (tmp == NULL)
10029                 printf (_("<corrupt time val: %lx"),
10030                         (unsigned long) atime);
10031               else
10032                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10033                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10034                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10035
10036             }
10037           break;
10038
10039         case DT_GNU_HASH:
10040           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10041           if (do_dynamic)
10042             {
10043               print_vma (entry->d_un.d_val, PREFIX_HEX);
10044               putchar ('\n');
10045             }
10046           break;
10047
10048         default:
10049           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10050             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10051               entry->d_un.d_val;
10052
10053           if (do_dynamic)
10054             {
10055               switch (elf_header.e_machine)
10056                 {
10057                 case EM_MIPS:
10058                 case EM_MIPS_RS3_LE:
10059                   dynamic_section_mips_val (entry);
10060                   break;
10061                 case EM_PARISC:
10062                   dynamic_section_parisc_val (entry);
10063                   break;
10064                 case EM_IA_64:
10065                   dynamic_section_ia64_val (entry);
10066                   break;
10067                 default:
10068                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10069                   putchar ('\n');
10070                 }
10071             }
10072           break;
10073         }
10074     }
10075
10076   return TRUE;
10077 }
10078
10079 static char *
10080 get_ver_flags (unsigned int flags)
10081 {
10082   static char buff[32];
10083
10084   buff[0] = 0;
10085
10086   if (flags == 0)
10087     return _("none");
10088
10089   if (flags & VER_FLG_BASE)
10090     strcat (buff, "BASE");
10091
10092   if (flags & VER_FLG_WEAK)
10093     {
10094       if (flags & VER_FLG_BASE)
10095         strcat (buff, " | ");
10096
10097       strcat (buff, "WEAK");
10098     }
10099
10100   if (flags & VER_FLG_INFO)
10101     {
10102       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10103         strcat (buff, " | ");
10104
10105       strcat (buff, "INFO");
10106     }
10107
10108   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10109     {
10110       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10111         strcat (buff, " | ");
10112
10113       strcat (buff, _("<unknown>"));
10114     }
10115
10116   return buff;
10117 }
10118
10119 /* Display the contents of the version sections.  */
10120
10121 static bfd_boolean
10122 process_version_sections (FILE * file)
10123 {
10124   Elf_Internal_Shdr * section;
10125   unsigned i;
10126   bfd_boolean found = FALSE;
10127
10128   if (! do_version)
10129     return TRUE;
10130
10131   for (i = 0, section = section_headers;
10132        i < elf_header.e_shnum;
10133        i++, section++)
10134     {
10135       switch (section->sh_type)
10136         {
10137         case SHT_GNU_verdef:
10138           {
10139             Elf_External_Verdef * edefs;
10140             unsigned int idx;
10141             unsigned int cnt;
10142             unsigned int end;
10143             char * endbuf;
10144
10145             found = TRUE;
10146
10147             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10148                     printable_section_name (section),
10149                     section->sh_info);
10150
10151             printf (_("  Addr: 0x"));
10152             printf_vma (section->sh_addr);
10153             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10154                     (unsigned long) section->sh_offset, section->sh_link,
10155                     printable_section_name_from_index (section->sh_link));
10156
10157             edefs = (Elf_External_Verdef *)
10158                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10159                           _("version definition section"));
10160             if (!edefs)
10161               break;
10162             endbuf = (char *) edefs + section->sh_size;
10163
10164             /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
10165             end = (section->sh_info < section->sh_size
10166                    ? section->sh_info : section->sh_size);
10167             for (idx = cnt = 0; cnt < end; ++cnt)
10168               {
10169                 char * vstart;
10170                 Elf_External_Verdef * edef;
10171                 Elf_Internal_Verdef ent;
10172                 Elf_External_Verdaux * eaux;
10173                 Elf_Internal_Verdaux aux;
10174                 unsigned int isum;
10175                 int j;
10176
10177                 /* Check for very large indices.  */
10178                 if (idx > (size_t) (endbuf - (char *) edefs))
10179                   break;
10180
10181                 vstart = ((char *) edefs) + idx;
10182                 if (vstart + sizeof (*edef) > endbuf)
10183                   break;
10184
10185                 edef = (Elf_External_Verdef *) vstart;
10186
10187                 ent.vd_version = BYTE_GET (edef->vd_version);
10188                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10189                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10190                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10191                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10192                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10193                 ent.vd_next    = BYTE_GET (edef->vd_next);
10194
10195                 printf (_("  %#06x: Rev: %d  Flags: %s"),
10196                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10197
10198                 printf (_("  Index: %d  Cnt: %d  "),
10199                         ent.vd_ndx, ent.vd_cnt);
10200
10201                 /* Check for overflow and underflow.  */
10202                 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart)
10203                     || (vstart + ent.vd_aux < vstart))
10204                   break;
10205
10206                 vstart += ent.vd_aux;
10207
10208                 eaux = (Elf_External_Verdaux *) vstart;
10209
10210                 aux.vda_name = BYTE_GET (eaux->vda_name);
10211                 aux.vda_next = BYTE_GET (eaux->vda_next);
10212
10213                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10214                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10215                 else
10216                   printf (_("Name index: %ld\n"), aux.vda_name);
10217
10218                 isum = idx + ent.vd_aux;
10219
10220                 for (j = 1; j < ent.vd_cnt; j++)
10221                   {
10222                     /* Check for overflow.  */
10223                     if (aux.vda_next > (size_t) (endbuf - vstart))
10224                       break;
10225
10226                     isum   += aux.vda_next;
10227                     vstart += aux.vda_next;
10228
10229                     eaux = (Elf_External_Verdaux *) vstart;
10230                     if (vstart + sizeof (*eaux) > endbuf)
10231                       break;
10232
10233                     aux.vda_name = BYTE_GET (eaux->vda_name);
10234                     aux.vda_next = BYTE_GET (eaux->vda_next);
10235
10236                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10237                       printf (_("  %#06x: Parent %d: %s\n"),
10238                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10239                     else
10240                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
10241                               isum, j, aux.vda_name);
10242                   }
10243
10244                 if (j < ent.vd_cnt)
10245                   printf (_("  Version def aux past end of section\n"));
10246
10247                 /* PR 17531:
10248                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10249                 if (idx + ent.vd_next < idx)
10250                   break;
10251
10252                 idx += ent.vd_next;
10253               }
10254
10255             if (cnt < section->sh_info)
10256               printf (_("  Version definition past end of section\n"));
10257
10258             free (edefs);
10259           }
10260           break;
10261
10262         case SHT_GNU_verneed:
10263           {
10264             Elf_External_Verneed * eneed;
10265             unsigned int idx;
10266             unsigned int cnt;
10267             char * endbuf;
10268
10269             found = TRUE;
10270
10271             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10272                     printable_section_name (section), section->sh_info);
10273
10274             printf (_(" Addr: 0x"));
10275             printf_vma (section->sh_addr);
10276             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10277                     (unsigned long) section->sh_offset, section->sh_link,
10278                     printable_section_name_from_index (section->sh_link));
10279
10280             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10281                                                        section->sh_offset, 1,
10282                                                        section->sh_size,
10283                                                        _("Version Needs section"));
10284             if (!eneed)
10285               break;
10286             endbuf = (char *) eneed + section->sh_size;
10287
10288             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10289               {
10290                 Elf_External_Verneed * entry;
10291                 Elf_Internal_Verneed ent;
10292                 unsigned int isum;
10293                 int j;
10294                 char * vstart;
10295
10296                 if (idx > (size_t) (endbuf - (char *) eneed))
10297                   break;
10298
10299                 vstart = ((char *) eneed) + idx;
10300                 if (vstart + sizeof (*entry) > endbuf)
10301                   break;
10302
10303                 entry = (Elf_External_Verneed *) vstart;
10304
10305                 ent.vn_version = BYTE_GET (entry->vn_version);
10306                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10307                 ent.vn_file    = BYTE_GET (entry->vn_file);
10308                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10309                 ent.vn_next    = BYTE_GET (entry->vn_next);
10310
10311                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
10312
10313                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10314                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10315                 else
10316                   printf (_("  File: %lx"), ent.vn_file);
10317
10318                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10319
10320                 /* Check for overflow.  */
10321                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10322                   break;
10323                 vstart += ent.vn_aux;
10324
10325                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10326                   {
10327                     Elf_External_Vernaux * eaux;
10328                     Elf_Internal_Vernaux aux;
10329
10330                     if (vstart + sizeof (*eaux) > endbuf)
10331                       break;
10332                     eaux = (Elf_External_Vernaux *) vstart;
10333
10334                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10335                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10336                     aux.vna_other = BYTE_GET (eaux->vna_other);
10337                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10338                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10339
10340                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10341                       printf (_("  %#06x:   Name: %s"),
10342                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10343                     else
10344                       printf (_("  %#06x:   Name index: %lx"),
10345                               isum, aux.vna_name);
10346
10347                     printf (_("  Flags: %s  Version: %d\n"),
10348                             get_ver_flags (aux.vna_flags), aux.vna_other);
10349
10350                     /* Check for overflow.  */
10351                     if (aux.vna_next > (size_t) (endbuf - vstart)
10352                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10353                       {
10354                         warn (_("Invalid vna_next field of %lx\n"),
10355                               aux.vna_next);
10356                         j = ent.vn_cnt;
10357                         break;
10358                       }
10359                     isum   += aux.vna_next;
10360                     vstart += aux.vna_next;
10361                   }
10362
10363                 if (j < ent.vn_cnt)
10364                   warn (_("Missing Version Needs auxillary information\n"));
10365
10366                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
10367                   {
10368                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10369                     cnt = section->sh_info;
10370                     break;
10371                   }
10372                 idx += ent.vn_next;
10373               }
10374
10375             if (cnt < section->sh_info)
10376               warn (_("Missing Version Needs information\n"));
10377
10378             free (eneed);
10379           }
10380           break;
10381
10382         case SHT_GNU_versym:
10383           {
10384             Elf_Internal_Shdr * link_section;
10385             size_t total;
10386             unsigned int cnt;
10387             unsigned char * edata;
10388             unsigned short * data;
10389             char * strtab;
10390             Elf_Internal_Sym * symbols;
10391             Elf_Internal_Shdr * string_sec;
10392             unsigned long num_syms;
10393             long off;
10394
10395             if (section->sh_link >= elf_header.e_shnum)
10396               break;
10397
10398             link_section = section_headers + section->sh_link;
10399             total = section->sh_size / sizeof (Elf_External_Versym);
10400
10401             if (link_section->sh_link >= elf_header.e_shnum)
10402               break;
10403
10404             found = TRUE;
10405
10406             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10407             if (symbols == NULL)
10408               break;
10409
10410             string_sec = section_headers + link_section->sh_link;
10411
10412             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10413                                         string_sec->sh_size,
10414                                         _("version string table"));
10415             if (!strtab)
10416               {
10417                 free (symbols);
10418                 break;
10419               }
10420
10421             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10422                     printable_section_name (section), (unsigned long) total);
10423
10424             printf (_(" Addr: "));
10425             printf_vma (section->sh_addr);
10426             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10427                     (unsigned long) section->sh_offset, section->sh_link,
10428                     printable_section_name (link_section));
10429
10430             off = offset_from_vma (file,
10431                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10432                                    total * sizeof (short));
10433             edata = (unsigned char *) get_data (NULL, file, off, total,
10434                                                 sizeof (short),
10435                                                 _("version symbol data"));
10436             if (!edata)
10437               {
10438                 free (strtab);
10439                 free (symbols);
10440                 break;
10441               }
10442
10443             data = (short unsigned int *) cmalloc (total, sizeof (short));
10444
10445             for (cnt = total; cnt --;)
10446               data[cnt] = byte_get (edata + cnt * sizeof (short),
10447                                     sizeof (short));
10448
10449             free (edata);
10450
10451             for (cnt = 0; cnt < total; cnt += 4)
10452               {
10453                 int j, nn;
10454                 char *name;
10455                 char *invalid = _("*invalid*");
10456
10457                 printf ("  %03x:", cnt);
10458
10459                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10460                   switch (data[cnt + j])
10461                     {
10462                     case 0:
10463                       fputs (_("   0 (*local*)    "), stdout);
10464                       break;
10465
10466                     case 1:
10467                       fputs (_("   1 (*global*)   "), stdout);
10468                       break;
10469
10470                     default:
10471                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10472                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10473
10474                       /* If this index value is greater than the size of the symbols
10475                          array, break to avoid an out-of-bounds read.  */
10476                       if ((unsigned long)(cnt + j) >= num_syms)
10477                         {
10478                           warn (_("invalid index into symbol array\n"));
10479                           break;
10480                         }
10481
10482                       name = NULL;
10483                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10484                         {
10485                           Elf_Internal_Verneed ivn;
10486                           unsigned long offset;
10487
10488                           offset = offset_from_vma
10489                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10490                              sizeof (Elf_External_Verneed));
10491
10492                           do
10493                             {
10494                               Elf_Internal_Vernaux ivna;
10495                               Elf_External_Verneed evn;
10496                               Elf_External_Vernaux evna;
10497                               unsigned long a_off;
10498
10499                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10500                                             _("version need")) == NULL)
10501                                 break;
10502
10503                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10504                               ivn.vn_next = BYTE_GET (evn.vn_next);
10505
10506                               a_off = offset + ivn.vn_aux;
10507
10508                               do
10509                                 {
10510                                   if (get_data (&evna, file, a_off, sizeof (evna),
10511                                                 1, _("version need aux (2)")) == NULL)
10512                                     {
10513                                       ivna.vna_next  = 0;
10514                                       ivna.vna_other = 0;
10515                                     }
10516                                   else
10517                                     {
10518                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10519                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10520                                     }
10521
10522                                   a_off += ivna.vna_next;
10523                                 }
10524                               while (ivna.vna_other != data[cnt + j]
10525                                      && ivna.vna_next != 0);
10526
10527                               if (ivna.vna_other == data[cnt + j])
10528                                 {
10529                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10530
10531                                   if (ivna.vna_name >= string_sec->sh_size)
10532                                     name = invalid;
10533                                   else
10534                                     name = strtab + ivna.vna_name;
10535                                   break;
10536                                 }
10537
10538                               offset += ivn.vn_next;
10539                             }
10540                           while (ivn.vn_next);
10541                         }
10542
10543                       if (data[cnt + j] != 0x8001
10544                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10545                         {
10546                           Elf_Internal_Verdef ivd;
10547                           Elf_External_Verdef evd;
10548                           unsigned long offset;
10549
10550                           offset = offset_from_vma
10551                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10552                              sizeof evd);
10553
10554                           do
10555                             {
10556                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10557                                             _("version def")) == NULL)
10558                                 {
10559                                   ivd.vd_next = 0;
10560                                   /* PR 17531: file: 046-1082287-0.004.  */
10561                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10562                                   break;
10563                                 }
10564                               else
10565                                 {
10566                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10567                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10568                                 }
10569
10570                               offset += ivd.vd_next;
10571                             }
10572                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10573                                  && ivd.vd_next != 0);
10574
10575                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10576                             {
10577                               Elf_External_Verdaux evda;
10578                               Elf_Internal_Verdaux ivda;
10579
10580                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10581
10582                               if (get_data (&evda, file,
10583                                             offset - ivd.vd_next + ivd.vd_aux,
10584                                             sizeof (evda), 1,
10585                                             _("version def aux")) == NULL)
10586                                 break;
10587
10588                               ivda.vda_name = BYTE_GET (evda.vda_name);
10589
10590                               if (ivda.vda_name >= string_sec->sh_size)
10591                                 name = invalid;
10592                               else if (name != NULL && name != invalid)
10593                                 name = _("*both*");
10594                               else
10595                                 name = strtab + ivda.vda_name;
10596                             }
10597                         }
10598                       if (name != NULL)
10599                         nn += printf ("(%s%-*s",
10600                                       name,
10601                                       12 - (int) strlen (name),
10602                                       ")");
10603
10604                       if (nn < 18)
10605                         printf ("%*c", 18 - nn, ' ');
10606                     }
10607
10608                 putchar ('\n');
10609               }
10610
10611             free (data);
10612             free (strtab);
10613             free (symbols);
10614           }
10615           break;
10616
10617         default:
10618           break;
10619         }
10620     }
10621
10622   if (! found)
10623     printf (_("\nNo version information found in this file.\n"));
10624
10625   return TRUE;
10626 }
10627
10628 static const char *
10629 get_symbol_binding (unsigned int binding)
10630 {
10631   static char buff[32];
10632
10633   switch (binding)
10634     {
10635     case STB_LOCAL:     return "LOCAL";
10636     case STB_GLOBAL:    return "GLOBAL";
10637     case STB_WEAK:      return "WEAK";
10638     default:
10639       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10640         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10641                   binding);
10642       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10643         {
10644           if (binding == STB_GNU_UNIQUE
10645               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10646                   /* GNU is still using the default value 0.  */
10647                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10648             return "UNIQUE";
10649           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10650         }
10651       else
10652         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10653       return buff;
10654     }
10655 }
10656
10657 static const char *
10658 get_symbol_type (unsigned int type)
10659 {
10660   static char buff[32];
10661
10662   switch (type)
10663     {
10664     case STT_NOTYPE:    return "NOTYPE";
10665     case STT_OBJECT:    return "OBJECT";
10666     case STT_FUNC:      return "FUNC";
10667     case STT_SECTION:   return "SECTION";
10668     case STT_FILE:      return "FILE";
10669     case STT_COMMON:    return "COMMON";
10670     case STT_TLS:       return "TLS";
10671     case STT_RELC:      return "RELC";
10672     case STT_SRELC:     return "SRELC";
10673     default:
10674       if (type >= STT_LOPROC && type <= STT_HIPROC)
10675         {
10676           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10677             return "THUMB_FUNC";
10678
10679           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10680             return "REGISTER";
10681
10682           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10683             return "PARISC_MILLI";
10684
10685           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10686         }
10687       else if (type >= STT_LOOS && type <= STT_HIOS)
10688         {
10689           if (elf_header.e_machine == EM_PARISC)
10690             {
10691               if (type == STT_HP_OPAQUE)
10692                 return "HP_OPAQUE";
10693               if (type == STT_HP_STUB)
10694                 return "HP_STUB";
10695             }
10696
10697           if (type == STT_GNU_IFUNC
10698               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10699                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10700                   /* GNU is still using the default value 0.  */
10701                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10702             return "IFUNC";
10703
10704           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10705         }
10706       else
10707         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10708       return buff;
10709     }
10710 }
10711
10712 static const char *
10713 get_symbol_visibility (unsigned int visibility)
10714 {
10715   switch (visibility)
10716     {
10717     case STV_DEFAULT:   return "DEFAULT";
10718     case STV_INTERNAL:  return "INTERNAL";
10719     case STV_HIDDEN:    return "HIDDEN";
10720     case STV_PROTECTED: return "PROTECTED";
10721     default:
10722       error (_("Unrecognized visibility value: %u"), visibility);
10723       return _("<unknown>");
10724     }
10725 }
10726
10727 static const char *
10728 get_solaris_symbol_visibility (unsigned int visibility)
10729 {
10730   switch (visibility)
10731     {
10732     case 4: return "EXPORTED";
10733     case 5: return "SINGLETON";
10734     case 6: return "ELIMINATE";
10735     default: return get_symbol_visibility (visibility);
10736     }
10737 }
10738
10739 static const char *
10740 get_mips_symbol_other (unsigned int other)
10741 {
10742   switch (other)
10743     {
10744     case STO_OPTIONAL:      return "OPTIONAL";
10745     case STO_MIPS_PLT:      return "MIPS PLT";
10746     case STO_MIPS_PIC:      return "MIPS PIC";
10747     case STO_MICROMIPS:     return "MICROMIPS";
10748     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10749     case STO_MIPS16:        return "MIPS16";
10750     default:                return NULL;
10751     }
10752 }
10753
10754 static const char *
10755 get_ia64_symbol_other (unsigned int other)
10756 {
10757   if (is_ia64_vms ())
10758     {
10759       static char res[32];
10760
10761       res[0] = 0;
10762
10763       /* Function types is for images and .STB files only.  */
10764       switch (elf_header.e_type)
10765         {
10766         case ET_DYN:
10767         case ET_EXEC:
10768           switch (VMS_ST_FUNC_TYPE (other))
10769             {
10770             case VMS_SFT_CODE_ADDR:
10771               strcat (res, " CA");
10772               break;
10773             case VMS_SFT_SYMV_IDX:
10774               strcat (res, " VEC");
10775               break;
10776             case VMS_SFT_FD:
10777               strcat (res, " FD");
10778               break;
10779             case VMS_SFT_RESERVE:
10780               strcat (res, " RSV");
10781               break;
10782             default:
10783               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10784                     VMS_ST_FUNC_TYPE (other));
10785               strcat (res, " <unknown>");
10786               break;
10787             }
10788           break;
10789         default:
10790           break;
10791         }
10792       switch (VMS_ST_LINKAGE (other))
10793         {
10794         case VMS_STL_IGNORE:
10795           strcat (res, " IGN");
10796           break;
10797         case VMS_STL_RESERVE:
10798           strcat (res, " RSV");
10799           break;
10800         case VMS_STL_STD:
10801           strcat (res, " STD");
10802           break;
10803         case VMS_STL_LNK:
10804           strcat (res, " LNK");
10805           break;
10806         default:
10807           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10808                 VMS_ST_LINKAGE (other));
10809           strcat (res, " <unknown>");
10810           break;
10811         }
10812
10813       if (res[0] != 0)
10814         return res + 1;
10815       else
10816         return res;
10817     }
10818   return NULL;
10819 }
10820
10821 static const char *
10822 get_ppc64_symbol_other (unsigned int other)
10823 {
10824   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10825     {
10826       static char buf[32];
10827       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10828                 PPC64_LOCAL_ENTRY_OFFSET (other));
10829       return buf;
10830     }
10831   return NULL;
10832 }
10833
10834 static const char *
10835 get_symbol_other (unsigned int other)
10836 {
10837   const char * result = NULL;
10838   static char buff [32];
10839
10840   if (other == 0)
10841     return "";
10842
10843   switch (elf_header.e_machine)
10844     {
10845     case EM_MIPS:
10846       result = get_mips_symbol_other (other);
10847       break;
10848     case EM_IA_64:
10849       result = get_ia64_symbol_other (other);
10850       break;
10851     case EM_PPC64:
10852       result = get_ppc64_symbol_other (other);
10853       break;
10854     default:
10855       result = NULL;
10856       break;
10857     }
10858
10859   if (result)
10860     return result;
10861
10862   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10863   return buff;
10864 }
10865
10866 static const char *
10867 get_symbol_index_type (unsigned int type)
10868 {
10869   static char buff[32];
10870
10871   switch (type)
10872     {
10873     case SHN_UNDEF:     return "UND";
10874     case SHN_ABS:       return "ABS";
10875     case SHN_COMMON:    return "COM";
10876     default:
10877       if (type == SHN_IA_64_ANSI_COMMON
10878           && elf_header.e_machine == EM_IA_64
10879           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10880         return "ANSI_COM";
10881       else if ((elf_header.e_machine == EM_X86_64
10882                 || elf_header.e_machine == EM_L1OM
10883                 || elf_header.e_machine == EM_K1OM)
10884                && type == SHN_X86_64_LCOMMON)
10885         return "LARGE_COM";
10886       else if ((type == SHN_MIPS_SCOMMON
10887                 && elf_header.e_machine == EM_MIPS)
10888                || (type == SHN_TIC6X_SCOMMON
10889                    && elf_header.e_machine == EM_TI_C6000))
10890         return "SCOM";
10891       else if (type == SHN_MIPS_SUNDEFINED
10892                && elf_header.e_machine == EM_MIPS)
10893         return "SUND";
10894       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10895         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10896       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10897         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10898       else if (type >= SHN_LORESERVE)
10899         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10900       else if (type >= elf_header.e_shnum)
10901         sprintf (buff, _("bad section index[%3d]"), type);
10902       else
10903         sprintf (buff, "%3d", type);
10904       break;
10905     }
10906
10907   return buff;
10908 }
10909
10910 static bfd_vma *
10911 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10912 {
10913   unsigned char * e_data;
10914   bfd_vma * i_data;
10915
10916   /* If the size_t type is smaller than the bfd_size_type, eg because
10917      you are building a 32-bit tool on a 64-bit host, then make sure
10918      that when (number) is cast to (size_t) no information is lost.  */
10919   if (sizeof (size_t) < sizeof (bfd_size_type)
10920       && (bfd_size_type) ((size_t) number) != number)
10921     {
10922       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10923                " elements of size %u\n"),
10924              number, ent_size);
10925       return NULL;
10926     }
10927
10928   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10929      attempting to allocate memory when the read is bound to fail.  */
10930   if (ent_size * number > current_file_size)
10931     {
10932       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10933              number);
10934       return NULL;
10935     }
10936
10937   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10938   if (e_data == NULL)
10939     {
10940       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10941              number);
10942       return NULL;
10943     }
10944
10945   if (fread (e_data, ent_size, (size_t) number, file) != number)
10946     {
10947       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10948              number * ent_size);
10949       free (e_data);
10950       return NULL;
10951     }
10952
10953   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10954   if (i_data == NULL)
10955     {
10956       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10957                " dynamic entries\n"),
10958              number);
10959       free (e_data);
10960       return NULL;
10961     }
10962
10963   while (number--)
10964     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10965
10966   free (e_data);
10967
10968   return i_data;
10969 }
10970
10971 static void
10972 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10973 {
10974   Elf_Internal_Sym * psym;
10975   int n;
10976
10977   n = print_vma (si, DEC_5);
10978   if (n < 5)
10979     fputs (&"     "[n], stdout);
10980   printf (" %3lu: ", hn);
10981
10982   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10983     {
10984       printf (_("<No info available for dynamic symbol number %lu>\n"),
10985               (unsigned long) si);
10986       return;
10987     }
10988
10989   psym = dynamic_symbols + si;
10990   print_vma (psym->st_value, LONG_HEX);
10991   putchar (' ');
10992   print_vma (psym->st_size, DEC_5);
10993
10994   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10995   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10996
10997   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10998     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
10999   else
11000     {
11001       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11002
11003       printf (" %-7s",  get_symbol_visibility (vis));
11004       /* Check to see if any other bits in the st_other field are set.
11005          Note - displaying this information disrupts the layout of the
11006          table being generated, but for the moment this case is very
11007          rare.  */
11008       if (psym->st_other ^ vis)
11009         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11010     }
11011
11012   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11013   if (VALID_DYNAMIC_NAME (psym->st_name))
11014     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11015   else
11016     printf (_(" <corrupt: %14ld>"), psym->st_name);
11017   putchar ('\n');
11018 }
11019
11020 static const char *
11021 get_symbol_version_string (FILE *                       file,
11022                            bfd_boolean                  is_dynsym,
11023                            const char *                 strtab,
11024                            unsigned long int            strtab_size,
11025                            unsigned int                 si,
11026                            Elf_Internal_Sym *           psym,
11027                            enum versioned_symbol_info * sym_info,
11028                            unsigned short *             vna_other)
11029 {
11030   unsigned char data[2];
11031   unsigned short vers_data;
11032   unsigned long offset;
11033
11034   if (!is_dynsym
11035       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11036     return NULL;
11037
11038   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11039                             sizeof data + si * sizeof (vers_data));
11040
11041   if (get_data (&data, file, offset + si * sizeof (vers_data),
11042                 sizeof (data), 1, _("version data")) == NULL)
11043     return NULL;
11044
11045   vers_data = byte_get (data, 2);
11046
11047   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11048     return NULL;
11049
11050   /* Usually we'd only see verdef for defined symbols, and verneed for
11051      undefined symbols.  However, symbols defined by the linker in
11052      .dynbss for variables copied from a shared library in order to
11053      avoid text relocations are defined yet have verneed.  We could
11054      use a heuristic to detect the special case, for example, check
11055      for verneed first on symbols defined in SHT_NOBITS sections, but
11056      it is simpler and more reliable to just look for both verdef and
11057      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11058
11059   if (psym->st_shndx != SHN_UNDEF
11060       && vers_data != 0x8001
11061       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11062     {
11063       Elf_Internal_Verdef ivd;
11064       Elf_Internal_Verdaux ivda;
11065       Elf_External_Verdaux evda;
11066       unsigned long off;
11067
11068       off = offset_from_vma (file,
11069                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11070                              sizeof (Elf_External_Verdef));
11071
11072       do
11073         {
11074           Elf_External_Verdef evd;
11075
11076           if (get_data (&evd, file, off, sizeof (evd), 1,
11077                         _("version def")) == NULL)
11078             {
11079               ivd.vd_ndx = 0;
11080               ivd.vd_aux = 0;
11081               ivd.vd_next = 0;
11082             }
11083           else
11084             {
11085               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11086               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11087               ivd.vd_next = BYTE_GET (evd.vd_next);
11088             }
11089
11090           off += ivd.vd_next;
11091         }
11092       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11093
11094       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11095         {
11096           off -= ivd.vd_next;
11097           off += ivd.vd_aux;
11098
11099           if (get_data (&evda, file, off, sizeof (evda), 1,
11100                         _("version def aux")) != NULL)
11101             {
11102               ivda.vda_name = BYTE_GET (evda.vda_name);
11103
11104               if (psym->st_name != ivda.vda_name)
11105                 {
11106                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11107                                ? symbol_hidden : symbol_public);
11108                   return (ivda.vda_name < strtab_size
11109                           ? strtab + ivda.vda_name : _("<corrupt>"));
11110                 }
11111             }
11112         }
11113     }
11114
11115   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11116     {
11117       Elf_External_Verneed evn;
11118       Elf_Internal_Verneed ivn;
11119       Elf_Internal_Vernaux ivna;
11120
11121       offset = offset_from_vma (file,
11122                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11123                                 sizeof evn);
11124       do
11125         {
11126           unsigned long vna_off;
11127
11128           if (get_data (&evn, file, offset, sizeof (evn), 1,
11129                         _("version need")) == NULL)
11130             {
11131               ivna.vna_next = 0;
11132               ivna.vna_other = 0;
11133               ivna.vna_name = 0;
11134               break;
11135             }
11136
11137           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11138           ivn.vn_next = BYTE_GET (evn.vn_next);
11139
11140           vna_off = offset + ivn.vn_aux;
11141
11142           do
11143             {
11144               Elf_External_Vernaux evna;
11145
11146               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11147                             _("version need aux (3)")) == NULL)
11148                 {
11149                   ivna.vna_next = 0;
11150                   ivna.vna_other = 0;
11151                   ivna.vna_name = 0;
11152                 }
11153               else
11154                 {
11155                   ivna.vna_other = BYTE_GET (evna.vna_other);
11156                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11157                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11158                 }
11159
11160               vna_off += ivna.vna_next;
11161             }
11162           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11163
11164           if (ivna.vna_other == vers_data)
11165             break;
11166
11167           offset += ivn.vn_next;
11168         }
11169       while (ivn.vn_next != 0);
11170
11171       if (ivna.vna_other == vers_data)
11172         {
11173           *sym_info = symbol_undefined;
11174           *vna_other = ivna.vna_other;
11175           return (ivna.vna_name < strtab_size
11176                   ? strtab + ivna.vna_name : _("<corrupt>"));
11177         }
11178     }
11179   return NULL;
11180 }
11181
11182 /* Dump the symbol table.  */
11183 static bfd_boolean
11184 process_symbol_table (FILE * file)
11185 {
11186   Elf_Internal_Shdr * section;
11187   bfd_size_type nbuckets = 0;
11188   bfd_size_type nchains = 0;
11189   bfd_vma * buckets = NULL;
11190   bfd_vma * chains = NULL;
11191   bfd_vma ngnubuckets = 0;
11192   bfd_vma * gnubuckets = NULL;
11193   bfd_vma * gnuchains = NULL;
11194   bfd_vma gnusymidx = 0;
11195   bfd_size_type ngnuchains = 0;
11196
11197   if (!do_syms && !do_dyn_syms && !do_histogram)
11198     return TRUE;
11199
11200   if (dynamic_info[DT_HASH]
11201       && (do_histogram
11202           || (do_using_dynamic
11203               && !do_dyn_syms
11204               && dynamic_strings != NULL)))
11205     {
11206       unsigned char nb[8];
11207       unsigned char nc[8];
11208       unsigned int hash_ent_size = 4;
11209
11210       if ((elf_header.e_machine == EM_ALPHA
11211            || elf_header.e_machine == EM_S390
11212            || elf_header.e_machine == EM_S390_OLD)
11213           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11214         hash_ent_size = 8;
11215
11216       if (fseek (file,
11217                  (archive_file_offset
11218                   + offset_from_vma (file, dynamic_info[DT_HASH],
11219                                      sizeof nb + sizeof nc)),
11220                  SEEK_SET))
11221         {
11222           error (_("Unable to seek to start of dynamic information\n"));
11223           goto no_hash;
11224         }
11225
11226       if (fread (nb, hash_ent_size, 1, file) != 1)
11227         {
11228           error (_("Failed to read in number of buckets\n"));
11229           goto no_hash;
11230         }
11231
11232       if (fread (nc, hash_ent_size, 1, file) != 1)
11233         {
11234           error (_("Failed to read in number of chains\n"));
11235           goto no_hash;
11236         }
11237
11238       nbuckets = byte_get (nb, hash_ent_size);
11239       nchains  = byte_get (nc, hash_ent_size);
11240
11241       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11242       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11243
11244     no_hash:
11245       if (buckets == NULL || chains == NULL)
11246         {
11247           if (do_using_dynamic)
11248             return FALSE;
11249           free (buckets);
11250           free (chains);
11251           buckets = NULL;
11252           chains = NULL;
11253           nbuckets = 0;
11254           nchains = 0;
11255         }
11256     }
11257
11258   if (dynamic_info_DT_GNU_HASH
11259       && (do_histogram
11260           || (do_using_dynamic
11261               && !do_dyn_syms
11262               && dynamic_strings != NULL)))
11263     {
11264       unsigned char nb[16];
11265       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11266       bfd_vma buckets_vma;
11267
11268       if (fseek (file,
11269                  (archive_file_offset
11270                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11271                                      sizeof nb)),
11272                  SEEK_SET))
11273         {
11274           error (_("Unable to seek to start of dynamic information\n"));
11275           goto no_gnu_hash;
11276         }
11277
11278       if (fread (nb, 16, 1, file) != 1)
11279         {
11280           error (_("Failed to read in number of buckets\n"));
11281           goto no_gnu_hash;
11282         }
11283
11284       ngnubuckets = byte_get (nb, 4);
11285       gnusymidx = byte_get (nb + 4, 4);
11286       bitmaskwords = byte_get (nb + 8, 4);
11287       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11288       if (is_32bit_elf)
11289         buckets_vma += bitmaskwords * 4;
11290       else
11291         buckets_vma += bitmaskwords * 8;
11292
11293       if (fseek (file,
11294                  (archive_file_offset
11295                   + offset_from_vma (file, buckets_vma, 4)),
11296                  SEEK_SET))
11297         {
11298           error (_("Unable to seek to start of dynamic information\n"));
11299           goto no_gnu_hash;
11300         }
11301
11302       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11303
11304       if (gnubuckets == NULL)
11305         goto no_gnu_hash;
11306
11307       for (i = 0; i < ngnubuckets; i++)
11308         if (gnubuckets[i] != 0)
11309           {
11310             if (gnubuckets[i] < gnusymidx)
11311               return FALSE;
11312
11313             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11314               maxchain = gnubuckets[i];
11315           }
11316
11317       if (maxchain == 0xffffffff)
11318         goto no_gnu_hash;
11319
11320       maxchain -= gnusymidx;
11321
11322       if (fseek (file,
11323                  (archive_file_offset
11324                   + offset_from_vma (file, buckets_vma
11325                                            + 4 * (ngnubuckets + maxchain), 4)),
11326                  SEEK_SET))
11327         {
11328           error (_("Unable to seek to start of dynamic information\n"));
11329           goto no_gnu_hash;
11330         }
11331
11332       do
11333         {
11334           if (fread (nb, 4, 1, file) != 1)
11335             {
11336               error (_("Failed to determine last chain length\n"));
11337               goto no_gnu_hash;
11338             }
11339
11340           if (maxchain + 1 == 0)
11341             goto no_gnu_hash;
11342
11343           ++maxchain;
11344         }
11345       while ((byte_get (nb, 4) & 1) == 0);
11346
11347       if (fseek (file,
11348                  (archive_file_offset
11349                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11350                  SEEK_SET))
11351         {
11352           error (_("Unable to seek to start of dynamic information\n"));
11353           goto no_gnu_hash;
11354         }
11355
11356       gnuchains = get_dynamic_data (file, maxchain, 4);
11357       ngnuchains = maxchain;
11358
11359     no_gnu_hash:
11360       if (gnuchains == NULL)
11361         {
11362           free (gnubuckets);
11363           gnubuckets = NULL;
11364           ngnubuckets = 0;
11365           if (do_using_dynamic)
11366             return FALSE;
11367         }
11368     }
11369
11370   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11371       && do_syms
11372       && do_using_dynamic
11373       && dynamic_strings != NULL
11374       && dynamic_symbols != NULL)
11375     {
11376       unsigned long hn;
11377
11378       if (dynamic_info[DT_HASH])
11379         {
11380           bfd_vma si;
11381
11382           printf (_("\nSymbol table for image:\n"));
11383           if (is_32bit_elf)
11384             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11385           else
11386             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11387
11388           for (hn = 0; hn < nbuckets; hn++)
11389             {
11390               if (! buckets[hn])
11391                 continue;
11392
11393               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11394                 print_dynamic_symbol (si, hn);
11395             }
11396         }
11397
11398       if (dynamic_info_DT_GNU_HASH)
11399         {
11400           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11401           if (is_32bit_elf)
11402             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11403           else
11404             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11405
11406           for (hn = 0; hn < ngnubuckets; ++hn)
11407             if (gnubuckets[hn] != 0)
11408               {
11409                 bfd_vma si = gnubuckets[hn];
11410                 bfd_vma off = si - gnusymidx;
11411
11412                 do
11413                   {
11414                     print_dynamic_symbol (si, hn);
11415                     si++;
11416                   }
11417                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11418               }
11419         }
11420     }
11421   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11422            && section_headers != NULL)
11423     {
11424       unsigned int i;
11425
11426       for (i = 0, section = section_headers;
11427            i < elf_header.e_shnum;
11428            i++, section++)
11429         {
11430           unsigned int si;
11431           char * strtab = NULL;
11432           unsigned long int strtab_size = 0;
11433           Elf_Internal_Sym * symtab;
11434           Elf_Internal_Sym * psym;
11435           unsigned long num_syms;
11436
11437           if ((section->sh_type != SHT_SYMTAB
11438                && section->sh_type != SHT_DYNSYM)
11439               || (!do_syms
11440                   && section->sh_type == SHT_SYMTAB))
11441             continue;
11442
11443           if (section->sh_entsize == 0)
11444             {
11445               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11446                       printable_section_name (section));
11447               continue;
11448             }
11449
11450           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11451                   printable_section_name (section),
11452                   (unsigned long) (section->sh_size / section->sh_entsize));
11453
11454           if (is_32bit_elf)
11455             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11456           else
11457             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11458
11459           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11460           if (symtab == NULL)
11461             continue;
11462
11463           if (section->sh_link == elf_header.e_shstrndx)
11464             {
11465               strtab = string_table;
11466               strtab_size = string_table_length;
11467             }
11468           else if (section->sh_link < elf_header.e_shnum)
11469             {
11470               Elf_Internal_Shdr * string_sec;
11471
11472               string_sec = section_headers + section->sh_link;
11473
11474               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11475                                           1, string_sec->sh_size,
11476                                           _("string table"));
11477               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11478             }
11479
11480           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11481             {
11482               const char *version_string;
11483               enum versioned_symbol_info sym_info;
11484               unsigned short vna_other;
11485
11486               printf ("%6d: ", si);
11487               print_vma (psym->st_value, LONG_HEX);
11488               putchar (' ');
11489               print_vma (psym->st_size, DEC_5);
11490               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11491               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11492               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11493                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11494               else
11495                 {
11496                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11497
11498                   printf (" %-7s", get_symbol_visibility (vis));
11499                   /* Check to see if any other bits in the st_other field are set.
11500                      Note - displaying this information disrupts the layout of the
11501                      table being generated, but for the moment this case is very rare.  */
11502                   if (psym->st_other ^ vis)
11503                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11504                 }
11505               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11506               print_symbol (25, psym->st_name < strtab_size
11507                             ? strtab + psym->st_name : _("<corrupt>"));
11508
11509               version_string
11510                 = get_symbol_version_string (file,
11511                                              section->sh_type == SHT_DYNSYM,
11512                                              strtab, strtab_size, si,
11513                                              psym, &sym_info, &vna_other);
11514               if (version_string)
11515                 {
11516                   if (sym_info == symbol_undefined)
11517                     printf ("@%s (%d)", version_string, vna_other);
11518                   else
11519                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11520                             version_string);
11521                 }
11522
11523               putchar ('\n');
11524
11525               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11526                   && si >= section->sh_info
11527                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11528                   && elf_header.e_machine != EM_MIPS
11529                   /* Solaris binaries have been found to violate this requirement as
11530                      well.  Not sure if this is a bug or an ABI requirement.  */
11531                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11532                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11533                       si, printable_section_name (section), section->sh_info);
11534             }
11535
11536           free (symtab);
11537           if (strtab != string_table)
11538             free (strtab);
11539         }
11540     }
11541   else if (do_syms)
11542     printf
11543       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11544
11545   if (do_histogram && buckets != NULL)
11546     {
11547       unsigned long * lengths;
11548       unsigned long * counts;
11549       unsigned long hn;
11550       bfd_vma si;
11551       unsigned long maxlength = 0;
11552       unsigned long nzero_counts = 0;
11553       unsigned long nsyms = 0;
11554       unsigned long chained;
11555
11556       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11557               (unsigned long) nbuckets);
11558
11559       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11560       if (lengths == NULL)
11561         {
11562           error (_("Out of memory allocating space for histogram buckets\n"));
11563           return FALSE;
11564         }
11565
11566       printf (_(" Length  Number     %% of total  Coverage\n"));
11567       for (hn = 0; hn < nbuckets; ++hn)
11568         {
11569           for (si = buckets[hn], chained = 0;
11570                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11571                si = chains[si], ++chained)
11572             {
11573               ++nsyms;
11574               if (maxlength < ++lengths[hn])
11575                 ++maxlength;
11576             }
11577
11578             /* PR binutils/17531: A corrupt binary could contain broken
11579                histogram data.  Do not go into an infinite loop trying
11580                to process it.  */
11581             if (chained > nchains)
11582               {
11583                 error (_("histogram chain is corrupt\n"));
11584                 break;
11585               }
11586         }
11587
11588       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11589       if (counts == NULL)
11590         {
11591           free (lengths);
11592           error (_("Out of memory allocating space for histogram counts\n"));
11593           return FALSE;
11594         }
11595
11596       for (hn = 0; hn < nbuckets; ++hn)
11597         ++counts[lengths[hn]];
11598
11599       if (nbuckets > 0)
11600         {
11601           unsigned long i;
11602           printf ("      0  %-10lu (%5.1f%%)\n",
11603                   counts[0], (counts[0] * 100.0) / nbuckets);
11604           for (i = 1; i <= maxlength; ++i)
11605             {
11606               nzero_counts += counts[i] * i;
11607               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11608                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11609                       (nzero_counts * 100.0) / nsyms);
11610             }
11611         }
11612
11613       free (counts);
11614       free (lengths);
11615     }
11616
11617   if (buckets != NULL)
11618     {
11619       free (buckets);
11620       free (chains);
11621     }
11622
11623   if (do_histogram && gnubuckets != NULL)
11624     {
11625       unsigned long * lengths;
11626       unsigned long * counts;
11627       unsigned long hn;
11628       unsigned long maxlength = 0;
11629       unsigned long nzero_counts = 0;
11630       unsigned long nsyms = 0;
11631
11632       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11633               (unsigned long) ngnubuckets);
11634
11635       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11636       if (lengths == NULL)
11637         {
11638           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11639           return FALSE;
11640         }
11641
11642       printf (_(" Length  Number     %% of total  Coverage\n"));
11643
11644       for (hn = 0; hn < ngnubuckets; ++hn)
11645         if (gnubuckets[hn] != 0)
11646           {
11647             bfd_vma off, length = 1;
11648
11649             for (off = gnubuckets[hn] - gnusymidx;
11650                  /* PR 17531 file: 010-77222-0.004.  */
11651                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11652                  ++off)
11653               ++length;
11654             lengths[hn] = length;
11655             if (length > maxlength)
11656               maxlength = length;
11657             nsyms += length;
11658           }
11659
11660       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11661       if (counts == NULL)
11662         {
11663           free (lengths);
11664           error (_("Out of memory allocating space for gnu histogram counts\n"));
11665           return FALSE;
11666         }
11667
11668       for (hn = 0; hn < ngnubuckets; ++hn)
11669         ++counts[lengths[hn]];
11670
11671       if (ngnubuckets > 0)
11672         {
11673           unsigned long j;
11674           printf ("      0  %-10lu (%5.1f%%)\n",
11675                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11676           for (j = 1; j <= maxlength; ++j)
11677             {
11678               nzero_counts += counts[j] * j;
11679               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11680                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11681                       (nzero_counts * 100.0) / nsyms);
11682             }
11683         }
11684
11685       free (counts);
11686       free (lengths);
11687       free (gnubuckets);
11688       free (gnuchains);
11689     }
11690
11691   return TRUE;
11692 }
11693
11694 static bfd_boolean
11695 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11696 {
11697   unsigned int i;
11698
11699   if (dynamic_syminfo == NULL
11700       || !do_dynamic)
11701     /* No syminfo, this is ok.  */
11702     return TRUE;
11703
11704   /* There better should be a dynamic symbol section.  */
11705   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11706     return FALSE;
11707
11708   if (dynamic_addr)
11709     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11710             dynamic_syminfo_offset, dynamic_syminfo_nent);
11711
11712   printf (_(" Num: Name                           BoundTo     Flags\n"));
11713   for (i = 0; i < dynamic_syminfo_nent; ++i)
11714     {
11715       unsigned short int flags = dynamic_syminfo[i].si_flags;
11716
11717       printf ("%4d: ", i);
11718       if (i >= num_dynamic_syms)
11719         printf (_("<corrupt index>"));
11720       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11721         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11722       else
11723         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11724       putchar (' ');
11725
11726       switch (dynamic_syminfo[i].si_boundto)
11727         {
11728         case SYMINFO_BT_SELF:
11729           fputs ("SELF       ", stdout);
11730           break;
11731         case SYMINFO_BT_PARENT:
11732           fputs ("PARENT     ", stdout);
11733           break;
11734         default:
11735           if (dynamic_syminfo[i].si_boundto > 0
11736               && dynamic_syminfo[i].si_boundto < dynamic_nent
11737               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11738             {
11739               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11740               putchar (' ' );
11741             }
11742           else
11743             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11744           break;
11745         }
11746
11747       if (flags & SYMINFO_FLG_DIRECT)
11748         printf (" DIRECT");
11749       if (flags & SYMINFO_FLG_PASSTHRU)
11750         printf (" PASSTHRU");
11751       if (flags & SYMINFO_FLG_COPY)
11752         printf (" COPY");
11753       if (flags & SYMINFO_FLG_LAZYLOAD)
11754         printf (" LAZYLOAD");
11755
11756       puts ("");
11757     }
11758
11759   return TRUE;
11760 }
11761
11762 #define IN_RANGE(START,END,ADDR,OFF)            \
11763   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11764
11765 /* Check to see if the given reloc needs to be handled in a target specific
11766    manner.  If so then process the reloc and return TRUE otherwise return
11767    FALSE.
11768
11769    If called with reloc == NULL, then this is a signal that reloc processing
11770    for the current section has finished, and any saved state should be
11771    discarded.  */
11772
11773 static bfd_boolean
11774 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11775                                 unsigned char *     start,
11776                                 unsigned char *     end,
11777                                 Elf_Internal_Sym *  symtab,
11778                                 unsigned long       num_syms)
11779 {
11780   unsigned int reloc_type = 0;
11781   unsigned long sym_index = 0;
11782
11783   if (reloc)
11784     {
11785       reloc_type = get_reloc_type (reloc->r_info);
11786       sym_index = get_reloc_symindex (reloc->r_info);
11787     }
11788
11789   switch (elf_header.e_machine)
11790     {
11791     case EM_MSP430:
11792     case EM_MSP430_OLD:
11793       {
11794         static Elf_Internal_Sym * saved_sym = NULL;
11795
11796         if (reloc == NULL)
11797           {
11798             saved_sym = NULL;
11799             return TRUE;
11800           }
11801
11802         switch (reloc_type)
11803           {
11804           case 10: /* R_MSP430_SYM_DIFF */
11805             if (uses_msp430x_relocs ())
11806               break;
11807             /* Fall through.  */
11808           case 21: /* R_MSP430X_SYM_DIFF */
11809             /* PR 21139.  */
11810             if (sym_index >= num_syms)
11811               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11812                      sym_index);
11813             else
11814               saved_sym = symtab + sym_index;
11815             return TRUE;
11816
11817           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11818           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11819             goto handle_sym_diff;
11820
11821           case 5: /* R_MSP430_16_BYTE */
11822           case 9: /* R_MSP430_8 */
11823             if (uses_msp430x_relocs ())
11824               break;
11825             goto handle_sym_diff;
11826
11827           case 2: /* R_MSP430_ABS16 */
11828           case 15: /* R_MSP430X_ABS16 */
11829             if (! uses_msp430x_relocs ())
11830               break;
11831             goto handle_sym_diff;
11832
11833           handle_sym_diff:
11834             if (saved_sym != NULL)
11835               {
11836                 int reloc_size = reloc_type == 1 ? 4 : 2;
11837                 bfd_vma value;
11838
11839                 if (sym_index >= num_syms)
11840                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11841                          sym_index);
11842                 else
11843                   {
11844                     value = reloc->r_addend + (symtab[sym_index].st_value
11845                                                - saved_sym->st_value);
11846
11847                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11848                       byte_put (start + reloc->r_offset, value, reloc_size);
11849                     else
11850                       /* PR 21137 */
11851                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11852                              (long) reloc->r_offset);
11853                   }
11854
11855                 saved_sym = NULL;
11856                 return TRUE;
11857               }
11858             break;
11859
11860           default:
11861             if (saved_sym != NULL)
11862               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11863             break;
11864           }
11865         break;
11866       }
11867
11868     case EM_MN10300:
11869     case EM_CYGNUS_MN10300:
11870       {
11871         static Elf_Internal_Sym * saved_sym = NULL;
11872
11873         if (reloc == NULL)
11874           {
11875             saved_sym = NULL;
11876             return TRUE;
11877           }
11878
11879         switch (reloc_type)
11880           {
11881           case 34: /* R_MN10300_ALIGN */
11882             return TRUE;
11883           case 33: /* R_MN10300_SYM_DIFF */
11884             if (sym_index >= num_syms)
11885               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11886                      sym_index);
11887             else
11888               saved_sym = symtab + sym_index;
11889             return TRUE;
11890
11891           case 1: /* R_MN10300_32 */
11892           case 2: /* R_MN10300_16 */
11893             if (saved_sym != NULL)
11894               {
11895                 int reloc_size = reloc_type == 1 ? 4 : 2;
11896                 bfd_vma value;
11897
11898                 if (sym_index >= num_syms)
11899                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11900                          sym_index);
11901                 else
11902                   {
11903                     value = reloc->r_addend + (symtab[sym_index].st_value
11904                                                - saved_sym->st_value);
11905
11906                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11907                       byte_put (start + reloc->r_offset, value, reloc_size);
11908                     else
11909                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11910                              (long) reloc->r_offset);
11911                   }
11912
11913                 saved_sym = NULL;
11914                 return TRUE;
11915               }
11916             break;
11917           default:
11918             if (saved_sym != NULL)
11919               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11920             break;
11921           }
11922         break;
11923       }
11924
11925     case EM_RL78:
11926       {
11927         static bfd_vma saved_sym1 = 0;
11928         static bfd_vma saved_sym2 = 0;
11929         static bfd_vma value;
11930
11931         if (reloc == NULL)
11932           {
11933             saved_sym1 = saved_sym2 = 0;
11934             return TRUE;
11935           }
11936
11937         switch (reloc_type)
11938           {
11939           case 0x80: /* R_RL78_SYM.  */
11940             saved_sym1 = saved_sym2;
11941             if (sym_index >= num_syms)
11942               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11943                      sym_index);
11944             else
11945               {
11946                 saved_sym2 = symtab[sym_index].st_value;
11947                 saved_sym2 += reloc->r_addend;
11948               }
11949             return TRUE;
11950
11951           case 0x83: /* R_RL78_OPsub.  */
11952             value = saved_sym1 - saved_sym2;
11953             saved_sym2 = saved_sym1 = 0;
11954             return TRUE;
11955             break;
11956
11957           case 0x41: /* R_RL78_ABS32.  */
11958             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11959               byte_put (start + reloc->r_offset, value, 4);
11960             else
11961               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11962                      (long) reloc->r_offset);
11963             value = 0;
11964             return TRUE;
11965
11966           case 0x43: /* R_RL78_ABS16.  */
11967             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11968               byte_put (start + reloc->r_offset, value, 2);
11969             else
11970               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11971                      (long) reloc->r_offset);
11972             value = 0;
11973             return TRUE;
11974
11975           default:
11976             break;
11977           }
11978         break;
11979       }
11980     }
11981
11982   return FALSE;
11983 }
11984
11985 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11986    DWARF debug sections.  This is a target specific test.  Note - we do not
11987    go through the whole including-target-headers-multiple-times route, (as
11988    we have already done with <elf/h8.h>) because this would become very
11989    messy and even then this function would have to contain target specific
11990    information (the names of the relocs instead of their numeric values).
11991    FIXME: This is not the correct way to solve this problem.  The proper way
11992    is to have target specific reloc sizing and typing functions created by
11993    the reloc-macros.h header, in the same way that it already creates the
11994    reloc naming functions.  */
11995
11996 static bfd_boolean
11997 is_32bit_abs_reloc (unsigned int reloc_type)
11998 {
11999   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12000   switch (elf_header.e_machine)
12001     {
12002     case EM_386:
12003     case EM_IAMCU:
12004       return reloc_type == 1; /* R_386_32.  */
12005     case EM_68K:
12006       return reloc_type == 1; /* R_68K_32.  */
12007     case EM_860:
12008       return reloc_type == 1; /* R_860_32.  */
12009     case EM_960:
12010       return reloc_type == 2; /* R_960_32.  */
12011     case EM_AARCH64:
12012       return (reloc_type == 258
12013               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12014     case EM_ADAPTEVA_EPIPHANY:
12015       return reloc_type == 3;
12016     case EM_ALPHA:
12017       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12018     case EM_ARC:
12019       return reloc_type == 1; /* R_ARC_32.  */
12020     case EM_ARC_COMPACT:
12021     case EM_ARC_COMPACT2:
12022       return reloc_type == 4; /* R_ARC_32.  */
12023     case EM_ARM:
12024       return reloc_type == 2; /* R_ARM_ABS32 */
12025     case EM_AVR_OLD:
12026     case EM_AVR:
12027       return reloc_type == 1;
12028     case EM_BLACKFIN:
12029       return reloc_type == 0x12; /* R_byte4_data.  */
12030     case EM_CRIS:
12031       return reloc_type == 3; /* R_CRIS_32.  */
12032     case EM_CR16:
12033       return reloc_type == 3; /* R_CR16_NUM32.  */
12034     case EM_CRX:
12035       return reloc_type == 15; /* R_CRX_NUM32.  */
12036     case EM_CYGNUS_FRV:
12037       return reloc_type == 1;
12038     case EM_CYGNUS_D10V:
12039     case EM_D10V:
12040       return reloc_type == 6; /* R_D10V_32.  */
12041     case EM_CYGNUS_D30V:
12042     case EM_D30V:
12043       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12044     case EM_DLX:
12045       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12046     case EM_CYGNUS_FR30:
12047     case EM_FR30:
12048       return reloc_type == 3; /* R_FR30_32.  */
12049     case EM_FT32:
12050       return reloc_type == 1; /* R_FT32_32.  */
12051     case EM_H8S:
12052     case EM_H8_300:
12053     case EM_H8_300H:
12054       return reloc_type == 1; /* R_H8_DIR32.  */
12055     case EM_IA_64:
12056       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12057         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
12058     case EM_IP2K_OLD:
12059     case EM_IP2K:
12060       return reloc_type == 2; /* R_IP2K_32.  */
12061     case EM_IQ2000:
12062       return reloc_type == 2; /* R_IQ2000_32.  */
12063     case EM_LATTICEMICO32:
12064       return reloc_type == 3; /* R_LM32_32.  */
12065     case EM_M32C_OLD:
12066     case EM_M32C:
12067       return reloc_type == 3; /* R_M32C_32.  */
12068     case EM_M32R:
12069       return reloc_type == 34; /* R_M32R_32_RELA.  */
12070     case EM_68HC11:
12071     case EM_68HC12:
12072       return reloc_type == 6; /* R_M68HC11_32.  */
12073     case EM_MCORE:
12074       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12075     case EM_CYGNUS_MEP:
12076       return reloc_type == 4; /* R_MEP_32.  */
12077     case EM_METAG:
12078       return reloc_type == 2; /* R_METAG_ADDR32.  */
12079     case EM_MICROBLAZE:
12080       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12081     case EM_MIPS:
12082       return reloc_type == 2; /* R_MIPS_32.  */
12083     case EM_MMIX:
12084       return reloc_type == 4; /* R_MMIX_32.  */
12085     case EM_CYGNUS_MN10200:
12086     case EM_MN10200:
12087       return reloc_type == 1; /* R_MN10200_32.  */
12088     case EM_CYGNUS_MN10300:
12089     case EM_MN10300:
12090       return reloc_type == 1; /* R_MN10300_32.  */
12091     case EM_MOXIE:
12092       return reloc_type == 1; /* R_MOXIE_32.  */
12093     case EM_MSP430_OLD:
12094     case EM_MSP430:
12095       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12096     case EM_MT:
12097       return reloc_type == 2; /* R_MT_32.  */
12098     case EM_NDS32:
12099       return reloc_type == 20; /* R_NDS32_RELA.  */
12100     case EM_ALTERA_NIOS2:
12101       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12102     case EM_NIOS32:
12103       return reloc_type == 1; /* R_NIOS_32.  */
12104     case EM_OR1K:
12105       return reloc_type == 1; /* R_OR1K_32.  */
12106     case EM_PARISC:
12107       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12108               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12109     case EM_PJ:
12110     case EM_PJ_OLD:
12111       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12112     case EM_PPC64:
12113       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12114     case EM_PPC:
12115       return reloc_type == 1; /* R_PPC_ADDR32.  */
12116     case EM_TI_PRU:
12117       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12118     case EM_RISCV:
12119       return reloc_type == 1; /* R_RISCV_32.  */
12120     case EM_RL78:
12121       return reloc_type == 1; /* R_RL78_DIR32.  */
12122     case EM_RX:
12123       return reloc_type == 1; /* R_RX_DIR32.  */
12124     case EM_S370:
12125       return reloc_type == 1; /* R_I370_ADDR31.  */
12126     case EM_S390_OLD:
12127     case EM_S390:
12128       return reloc_type == 4; /* R_S390_32.  */
12129     case EM_SCORE:
12130       return reloc_type == 8; /* R_SCORE_ABS32.  */
12131     case EM_SH:
12132       return reloc_type == 1; /* R_SH_DIR32.  */
12133     case EM_SPARC32PLUS:
12134     case EM_SPARCV9:
12135     case EM_SPARC:
12136       return reloc_type == 3 /* R_SPARC_32.  */
12137         || reloc_type == 23; /* R_SPARC_UA32.  */
12138     case EM_SPU:
12139       return reloc_type == 6; /* R_SPU_ADDR32 */
12140     case EM_TI_C6000:
12141       return reloc_type == 1; /* R_C6000_ABS32.  */
12142     case EM_TILEGX:
12143       return reloc_type == 2; /* R_TILEGX_32.  */
12144     case EM_TILEPRO:
12145       return reloc_type == 1; /* R_TILEPRO_32.  */
12146     case EM_CYGNUS_V850:
12147     case EM_V850:
12148       return reloc_type == 6; /* R_V850_ABS32.  */
12149     case EM_V800:
12150       return reloc_type == 0x33; /* R_V810_WORD.  */
12151     case EM_VAX:
12152       return reloc_type == 1; /* R_VAX_32.  */
12153     case EM_VISIUM:
12154       return reloc_type == 3;  /* R_VISIUM_32. */
12155     case EM_WEBASSEMBLY:
12156       return reloc_type == 1;  /* R_WASM32_32.  */
12157     case EM_X86_64:
12158     case EM_L1OM:
12159     case EM_K1OM:
12160       return reloc_type == 10; /* R_X86_64_32.  */
12161     case EM_XC16X:
12162     case EM_C166:
12163       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12164     case EM_XGATE:
12165       return reloc_type == 4; /* R_XGATE_32.  */
12166     case EM_XSTORMY16:
12167       return reloc_type == 1; /* R_XSTROMY16_32.  */
12168     case EM_XTENSA_OLD:
12169     case EM_XTENSA:
12170       return reloc_type == 1; /* R_XTENSA_32.  */
12171     default:
12172       {
12173         static unsigned int prev_warn = 0;
12174
12175         /* Avoid repeating the same warning multiple times.  */
12176         if (prev_warn != elf_header.e_machine)
12177           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12178                  elf_header.e_machine);
12179         prev_warn = elf_header.e_machine;
12180         return FALSE;
12181       }
12182     }
12183 }
12184
12185 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12186    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12187
12188 static bfd_boolean
12189 is_32bit_pcrel_reloc (unsigned int reloc_type)
12190 {
12191   switch (elf_header.e_machine)
12192   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12193     {
12194     case EM_386:
12195     case EM_IAMCU:
12196       return reloc_type == 2;  /* R_386_PC32.  */
12197     case EM_68K:
12198       return reloc_type == 4;  /* R_68K_PC32.  */
12199     case EM_AARCH64:
12200       return reloc_type == 261; /* R_AARCH64_PREL32 */
12201     case EM_ADAPTEVA_EPIPHANY:
12202       return reloc_type == 6;
12203     case EM_ALPHA:
12204       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12205     case EM_ARC_COMPACT:
12206     case EM_ARC_COMPACT2:
12207       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12208     case EM_ARM:
12209       return reloc_type == 3;  /* R_ARM_REL32 */
12210     case EM_AVR_OLD:
12211     case EM_AVR:
12212       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12213     case EM_MICROBLAZE:
12214       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12215     case EM_OR1K:
12216       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12217     case EM_PARISC:
12218       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12219     case EM_PPC:
12220       return reloc_type == 26; /* R_PPC_REL32.  */
12221     case EM_PPC64:
12222       return reloc_type == 26; /* R_PPC64_REL32.  */
12223     case EM_S390_OLD:
12224     case EM_S390:
12225       return reloc_type == 5;  /* R_390_PC32.  */
12226     case EM_SH:
12227       return reloc_type == 2;  /* R_SH_REL32.  */
12228     case EM_SPARC32PLUS:
12229     case EM_SPARCV9:
12230     case EM_SPARC:
12231       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12232     case EM_SPU:
12233       return reloc_type == 13; /* R_SPU_REL32.  */
12234     case EM_TILEGX:
12235       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12236     case EM_TILEPRO:
12237       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12238     case EM_VISIUM:
12239       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12240     case EM_X86_64:
12241     case EM_L1OM:
12242     case EM_K1OM:
12243       return reloc_type == 2;  /* R_X86_64_PC32.  */
12244     case EM_XTENSA_OLD:
12245     case EM_XTENSA:
12246       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12247     default:
12248       /* Do not abort or issue an error message here.  Not all targets use
12249          pc-relative 32-bit relocs in their DWARF debug information and we
12250          have already tested for target coverage in is_32bit_abs_reloc.  A
12251          more helpful warning message will be generated by apply_relocations
12252          anyway, so just return.  */
12253       return FALSE;
12254     }
12255 }
12256
12257 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12258    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12259
12260 static bfd_boolean
12261 is_64bit_abs_reloc (unsigned int reloc_type)
12262 {
12263   switch (elf_header.e_machine)
12264     {
12265     case EM_AARCH64:
12266       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12267     case EM_ALPHA:
12268       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12269     case EM_IA_64:
12270       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
12271     case EM_PARISC:
12272       return reloc_type == 80; /* R_PARISC_DIR64.  */
12273     case EM_PPC64:
12274       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12275     case EM_RISCV:
12276       return reloc_type == 2; /* R_RISCV_64.  */
12277     case EM_SPARC32PLUS:
12278     case EM_SPARCV9:
12279     case EM_SPARC:
12280       return reloc_type == 54; /* R_SPARC_UA64.  */
12281     case EM_X86_64:
12282     case EM_L1OM:
12283     case EM_K1OM:
12284       return reloc_type == 1; /* R_X86_64_64.  */
12285     case EM_S390_OLD:
12286     case EM_S390:
12287       return reloc_type == 22;  /* R_S390_64.  */
12288     case EM_TILEGX:
12289       return reloc_type == 1; /* R_TILEGX_64.  */
12290     case EM_MIPS:
12291       return reloc_type == 18;  /* R_MIPS_64.  */
12292     default:
12293       return FALSE;
12294     }
12295 }
12296
12297 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12298    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12299
12300 static bfd_boolean
12301 is_64bit_pcrel_reloc (unsigned int reloc_type)
12302 {
12303   switch (elf_header.e_machine)
12304     {
12305     case EM_AARCH64:
12306       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12307     case EM_ALPHA:
12308       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12309     case EM_IA_64:
12310       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
12311     case EM_PARISC:
12312       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12313     case EM_PPC64:
12314       return reloc_type == 44; /* R_PPC64_REL64.  */
12315     case EM_SPARC32PLUS:
12316     case EM_SPARCV9:
12317     case EM_SPARC:
12318       return reloc_type == 46; /* R_SPARC_DISP64.  */
12319     case EM_X86_64:
12320     case EM_L1OM:
12321     case EM_K1OM:
12322       return reloc_type == 24; /* R_X86_64_PC64.  */
12323     case EM_S390_OLD:
12324     case EM_S390:
12325       return reloc_type == 23;  /* R_S390_PC64.  */
12326     case EM_TILEGX:
12327       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12328     default:
12329       return FALSE;
12330     }
12331 }
12332
12333 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12334    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12335
12336 static bfd_boolean
12337 is_24bit_abs_reloc (unsigned int reloc_type)
12338 {
12339   switch (elf_header.e_machine)
12340     {
12341     case EM_CYGNUS_MN10200:
12342     case EM_MN10200:
12343       return reloc_type == 4; /* R_MN10200_24.  */
12344     case EM_FT32:
12345       return reloc_type == 5; /* R_FT32_20.  */
12346     default:
12347       return FALSE;
12348     }
12349 }
12350
12351 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12352    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12353
12354 static bfd_boolean
12355 is_16bit_abs_reloc (unsigned int reloc_type)
12356 {
12357   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12358   switch (elf_header.e_machine)
12359     {
12360     case EM_ARC:
12361     case EM_ARC_COMPACT:
12362     case EM_ARC_COMPACT2:
12363       return reloc_type == 2; /* R_ARC_16.  */
12364     case EM_ADAPTEVA_EPIPHANY:
12365       return reloc_type == 5;
12366     case EM_AVR_OLD:
12367     case EM_AVR:
12368       return reloc_type == 4; /* R_AVR_16.  */
12369     case EM_CYGNUS_D10V:
12370     case EM_D10V:
12371       return reloc_type == 3; /* R_D10V_16.  */
12372     case EM_H8S:
12373     case EM_H8_300:
12374     case EM_H8_300H:
12375       return reloc_type == R_H8_DIR16;
12376     case EM_IP2K_OLD:
12377     case EM_IP2K:
12378       return reloc_type == 1; /* R_IP2K_16.  */
12379     case EM_M32C_OLD:
12380     case EM_M32C:
12381       return reloc_type == 1; /* R_M32C_16 */
12382     case EM_CYGNUS_MN10200:
12383     case EM_MN10200:
12384       return reloc_type == 2; /* R_MN10200_16.  */
12385     case EM_CYGNUS_MN10300:
12386     case EM_MN10300:
12387       return reloc_type == 2; /* R_MN10300_16.  */
12388     case EM_MSP430:
12389       if (uses_msp430x_relocs ())
12390         return reloc_type == 2; /* R_MSP430_ABS16.  */
12391       /* Fall through.  */
12392     case EM_MSP430_OLD:
12393       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12394     case EM_NDS32:
12395       return reloc_type == 19; /* R_NDS32_RELA.  */
12396     case EM_ALTERA_NIOS2:
12397       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12398     case EM_NIOS32:
12399       return reloc_type == 9; /* R_NIOS_16.  */
12400     case EM_OR1K:
12401       return reloc_type == 2; /* R_OR1K_16.  */
12402     case EM_TI_PRU:
12403       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12404     case EM_TI_C6000:
12405       return reloc_type == 2; /* R_C6000_ABS16.  */
12406     case EM_VISIUM:
12407       return reloc_type == 2; /* R_VISIUM_16. */
12408     case EM_XC16X:
12409     case EM_C166:
12410       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12411     case EM_XGATE:
12412       return reloc_type == 3; /* R_XGATE_16.  */
12413     default:
12414       return FALSE;
12415     }
12416 }
12417
12418 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12419    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12420
12421 static bfd_boolean
12422 is_none_reloc (unsigned int reloc_type)
12423 {
12424   switch (elf_header.e_machine)
12425     {
12426     case EM_386:     /* R_386_NONE.  */
12427     case EM_68K:     /* R_68K_NONE.  */
12428     case EM_ADAPTEVA_EPIPHANY:
12429     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12430     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12431     case EM_ARC:     /* R_ARC_NONE.  */
12432     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12433     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12434     case EM_ARM:     /* R_ARM_NONE.  */
12435     case EM_C166:    /* R_XC16X_NONE.  */
12436     case EM_CRIS:    /* R_CRIS_NONE.  */
12437     case EM_FT32:    /* R_FT32_NONE.  */
12438     case EM_IA_64:   /* R_IA64_NONE.  */
12439     case EM_K1OM:    /* R_X86_64_NONE.  */
12440     case EM_L1OM:    /* R_X86_64_NONE.  */
12441     case EM_M32R:    /* R_M32R_NONE.  */
12442     case EM_MIPS:    /* R_MIPS_NONE.  */
12443     case EM_MN10300: /* R_MN10300_NONE.  */
12444     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12445     case EM_NIOS32:  /* R_NIOS_NONE.  */
12446     case EM_OR1K:    /* R_OR1K_NONE. */
12447     case EM_PARISC:  /* R_PARISC_NONE.  */
12448     case EM_PPC64:   /* R_PPC64_NONE.  */
12449     case EM_PPC:     /* R_PPC_NONE.  */
12450     case EM_RISCV:   /* R_RISCV_NONE.  */
12451     case EM_S390:    /* R_390_NONE.  */
12452     case EM_S390_OLD:
12453     case EM_SH:      /* R_SH_NONE.  */
12454     case EM_SPARC32PLUS:
12455     case EM_SPARC:   /* R_SPARC_NONE.  */
12456     case EM_SPARCV9:
12457     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12458     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12459     case EM_TI_C6000:/* R_C6000_NONE.  */
12460     case EM_X86_64:  /* R_X86_64_NONE.  */
12461     case EM_XC16X:
12462     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12463       return reloc_type == 0;
12464
12465     case EM_AARCH64:
12466       return reloc_type == 0 || reloc_type == 256;
12467     case EM_AVR_OLD:
12468     case EM_AVR:
12469       return (reloc_type == 0 /* R_AVR_NONE.  */
12470               || reloc_type == 30 /* R_AVR_DIFF8.  */
12471               || reloc_type == 31 /* R_AVR_DIFF16.  */
12472               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12473     case EM_METAG:
12474       return reloc_type == 3; /* R_METAG_NONE.  */
12475     case EM_NDS32:
12476       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12477               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12478               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12479               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12480               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12481     case EM_TI_PRU:
12482       return (reloc_type == 0       /* R_PRU_NONE.  */
12483               || reloc_type == 65   /* R_PRU_DIFF8.  */
12484               || reloc_type == 66   /* R_PRU_DIFF16.  */
12485               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12486     case EM_XTENSA_OLD:
12487     case EM_XTENSA:
12488       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12489               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12490               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12491               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12492     }
12493   return FALSE;
12494 }
12495
12496 /* Returns TRUE if there is a relocation against
12497    section NAME at OFFSET bytes.  */
12498
12499 bfd_boolean
12500 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12501 {
12502   Elf_Internal_Rela * relocs;
12503   Elf_Internal_Rela * rp;
12504
12505   if (dsec == NULL || dsec->reloc_info == NULL)
12506     return FALSE;
12507
12508   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12509
12510   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12511     if (rp->r_offset == offset)
12512       return TRUE;
12513
12514    return FALSE;
12515 }
12516
12517 /* Apply relocations to a section.
12518    Returns TRUE upon success, FALSE otherwise.
12519    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12520    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12521    will be set to the number of relocs loaded.
12522
12523    Note: So far support has been added only for those relocations
12524    which can be found in debug sections. FIXME: Add support for
12525    more relocations ?  */
12526
12527 static bfd_boolean
12528 apply_relocations (void *                     file,
12529                    const Elf_Internal_Shdr *  section,
12530                    unsigned char *            start,
12531                    bfd_size_type              size,
12532                    void **                    relocs_return,
12533                    unsigned long *            num_relocs_return)
12534 {
12535   Elf_Internal_Shdr * relsec;
12536   unsigned char * end = start + size;
12537   bfd_boolean res = TRUE;
12538
12539   if (relocs_return != NULL)
12540     {
12541       * (Elf_Internal_Rela **) relocs_return = NULL;
12542       * num_relocs_return = 0;
12543     }
12544
12545   if (elf_header.e_type != ET_REL)
12546     /* No relocs to apply.  */
12547     return TRUE;
12548
12549   /* Find the reloc section associated with the section.  */
12550   for (relsec = section_headers;
12551        relsec < section_headers + elf_header.e_shnum;
12552        ++relsec)
12553     {
12554       bfd_boolean is_rela;
12555       unsigned long num_relocs;
12556       Elf_Internal_Rela * relocs;
12557       Elf_Internal_Rela * rp;
12558       Elf_Internal_Shdr * symsec;
12559       Elf_Internal_Sym * symtab;
12560       unsigned long num_syms;
12561       Elf_Internal_Sym * sym;
12562
12563       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12564           || relsec->sh_info >= elf_header.e_shnum
12565           || section_headers + relsec->sh_info != section
12566           || relsec->sh_size == 0
12567           || relsec->sh_link >= elf_header.e_shnum)
12568         continue;
12569
12570       is_rela = relsec->sh_type == SHT_RELA;
12571
12572       if (is_rela)
12573         {
12574           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12575                                   relsec->sh_size, & relocs, & num_relocs))
12576             return FALSE;
12577         }
12578       else
12579         {
12580           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12581                                  relsec->sh_size, & relocs, & num_relocs))
12582             return FALSE;
12583         }
12584
12585       /* SH uses RELA but uses in place value instead of the addend field.  */
12586       if (elf_header.e_machine == EM_SH)
12587         is_rela = FALSE;
12588
12589       symsec = section_headers + relsec->sh_link;
12590       if (symsec->sh_type != SHT_SYMTAB
12591           && symsec->sh_type != SHT_DYNSYM)
12592         return FALSE;
12593       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12594
12595       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12596         {
12597           bfd_vma         addend;
12598           unsigned int    reloc_type;
12599           unsigned int    reloc_size;
12600           unsigned char * rloc;
12601           unsigned long   sym_index;
12602
12603           reloc_type = get_reloc_type (rp->r_info);
12604
12605           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12606             continue;
12607           else if (is_none_reloc (reloc_type))
12608             continue;
12609           else if (is_32bit_abs_reloc (reloc_type)
12610                    || is_32bit_pcrel_reloc (reloc_type))
12611             reloc_size = 4;
12612           else if (is_64bit_abs_reloc (reloc_type)
12613                    || is_64bit_pcrel_reloc (reloc_type))
12614             reloc_size = 8;
12615           else if (is_24bit_abs_reloc (reloc_type))
12616             reloc_size = 3;
12617           else if (is_16bit_abs_reloc (reloc_type))
12618             reloc_size = 2;
12619           else
12620             {
12621               static unsigned int prev_reloc = 0;
12622               if (reloc_type != prev_reloc)
12623                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12624                       reloc_type, printable_section_name (section));
12625               prev_reloc = reloc_type;
12626               res = FALSE;
12627               continue;
12628             }
12629
12630           rloc = start + rp->r_offset;
12631           if ((rloc + reloc_size) > end || (rloc < start))
12632             {
12633               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12634                     (unsigned long) rp->r_offset,
12635                     printable_section_name (section));
12636               res = FALSE;
12637               continue;
12638             }
12639
12640           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12641           if (sym_index >= num_syms)
12642             {
12643               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12644                     sym_index, printable_section_name (section));
12645               res = FALSE;
12646               continue;
12647             }
12648           sym = symtab + sym_index;
12649
12650           /* If the reloc has a symbol associated with it,
12651              make sure that it is of an appropriate type.
12652
12653              Relocations against symbols without type can happen.
12654              Gcc -feliminate-dwarf2-dups may generate symbols
12655              without type for debug info.
12656
12657              Icc generates relocations against function symbols
12658              instead of local labels.
12659
12660              Relocations against object symbols can happen, eg when
12661              referencing a global array.  For an example of this see
12662              the _clz.o binary in libgcc.a.  */
12663           if (sym != symtab
12664               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12665               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12666             {
12667               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12668                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12669                     (long int)(rp - relocs),
12670                     printable_section_name (relsec));
12671               res = FALSE;
12672               continue;
12673             }
12674
12675           addend = 0;
12676           if (is_rela)
12677             addend += rp->r_addend;
12678           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12679              partial_inplace.  */
12680           if (!is_rela
12681               || (elf_header.e_machine == EM_XTENSA
12682                   && reloc_type == 1)
12683               || ((elf_header.e_machine == EM_PJ
12684                    || elf_header.e_machine == EM_PJ_OLD)
12685                   && reloc_type == 1)
12686               || ((elf_header.e_machine == EM_D30V
12687                    || elf_header.e_machine == EM_CYGNUS_D30V)
12688                   && reloc_type == 12))
12689             addend += byte_get (rloc, reloc_size);
12690
12691           if (is_32bit_pcrel_reloc (reloc_type)
12692               || is_64bit_pcrel_reloc (reloc_type))
12693             {
12694               /* On HPPA, all pc-relative relocations are biased by 8.  */
12695               if (elf_header.e_machine == EM_PARISC)
12696                 addend -= 8;
12697               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12698                         reloc_size);
12699             }
12700           else
12701             byte_put (rloc, addend + sym->st_value, reloc_size);
12702         }
12703
12704       free (symtab);
12705       /* Let the target specific reloc processing code know that
12706          we have finished with these relocs.  */
12707       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12708
12709       if (relocs_return)
12710         {
12711           * (Elf_Internal_Rela **) relocs_return = relocs;
12712           * num_relocs_return = num_relocs;
12713         }
12714       else
12715         free (relocs);
12716
12717       break;
12718     }
12719
12720   return res;
12721 }
12722
12723 #ifdef SUPPORT_DISASSEMBLY
12724 static bfd_boolean
12725 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12726 {
12727   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12728
12729   /* FIXME: XXX -- to be done --- XXX */
12730
12731   return TRUE;
12732 }
12733 #endif
12734
12735 /* Reads in the contents of SECTION from FILE, returning a pointer
12736    to a malloc'ed buffer or NULL if something went wrong.  */
12737
12738 static char *
12739 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12740 {
12741   bfd_size_type num_bytes;
12742
12743   num_bytes = section->sh_size;
12744
12745   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12746     {
12747       printf (_("\nSection '%s' has no data to dump.\n"),
12748               printable_section_name (section));
12749       return NULL;
12750     }
12751
12752   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12753                              _("section contents"));
12754 }
12755
12756 /* Uncompresses a section that was compressed using zlib, in place.  */
12757
12758 static bfd_boolean
12759 uncompress_section_contents (unsigned char **buffer,
12760                              dwarf_size_type uncompressed_size,
12761                              dwarf_size_type *size)
12762 {
12763   dwarf_size_type compressed_size = *size;
12764   unsigned char * compressed_buffer = *buffer;
12765   unsigned char * uncompressed_buffer;
12766   z_stream strm;
12767   int rc;
12768
12769   /* It is possible the section consists of several compressed
12770      buffers concatenated together, so we uncompress in a loop.  */
12771   /* PR 18313: The state field in the z_stream structure is supposed
12772      to be invisible to the user (ie us), but some compilers will
12773      still complain about it being used without initialisation.  So
12774      we first zero the entire z_stream structure and then set the fields
12775      that we need.  */
12776   memset (& strm, 0, sizeof strm);
12777   strm.avail_in = compressed_size;
12778   strm.next_in = (Bytef *) compressed_buffer;
12779   strm.avail_out = uncompressed_size;
12780   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12781
12782   rc = inflateInit (& strm);
12783   while (strm.avail_in > 0)
12784     {
12785       if (rc != Z_OK)
12786         goto fail;
12787       strm.next_out = ((Bytef *) uncompressed_buffer
12788                        + (uncompressed_size - strm.avail_out));
12789       rc = inflate (&strm, Z_FINISH);
12790       if (rc != Z_STREAM_END)
12791         goto fail;
12792       rc = inflateReset (& strm);
12793     }
12794   rc = inflateEnd (& strm);
12795   if (rc != Z_OK
12796       || strm.avail_out != 0)
12797     goto fail;
12798
12799   *buffer = uncompressed_buffer;
12800   *size = uncompressed_size;
12801   return TRUE;
12802
12803  fail:
12804   free (uncompressed_buffer);
12805   /* Indicate decompression failure.  */
12806   *buffer = NULL;
12807   return FALSE;
12808 }
12809
12810 static bfd_boolean
12811 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12812 {
12813   Elf_Internal_Shdr *  relsec;
12814   bfd_size_type        num_bytes;
12815   unsigned char *      data;
12816   unsigned char *      end;
12817   unsigned char *      real_start;
12818   unsigned char *      start;
12819   bfd_boolean          some_strings_shown;
12820
12821   real_start = start = (unsigned char *) get_section_contents (section,
12822                                                                file);
12823   if (start == NULL)
12824     return FALSE;
12825   num_bytes = section->sh_size;
12826
12827   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12828
12829   if (decompress_dumps)
12830     {
12831       dwarf_size_type new_size = num_bytes;
12832       dwarf_size_type uncompressed_size = 0;
12833
12834       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12835         {
12836           Elf_Internal_Chdr chdr;
12837           unsigned int compression_header_size
12838             = get_compression_header (& chdr, (unsigned char *) start,
12839                                       num_bytes);
12840
12841           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12842             {
12843               warn (_("section '%s' has unsupported compress type: %d\n"),
12844                     printable_section_name (section), chdr.ch_type);
12845               return FALSE;
12846             }
12847           else if (chdr.ch_addralign != section->sh_addralign)
12848             {
12849               warn (_("compressed section '%s' is corrupted\n"),
12850                     printable_section_name (section));
12851               return FALSE;
12852             }
12853           uncompressed_size = chdr.ch_size;
12854           start += compression_header_size;
12855           new_size -= compression_header_size;
12856         }
12857       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12858         {
12859           /* Read the zlib header.  In this case, it should be "ZLIB"
12860              followed by the uncompressed section size, 8 bytes in
12861              big-endian order.  */
12862           uncompressed_size = start[4]; uncompressed_size <<= 8;
12863           uncompressed_size += start[5]; uncompressed_size <<= 8;
12864           uncompressed_size += start[6]; uncompressed_size <<= 8;
12865           uncompressed_size += start[7]; uncompressed_size <<= 8;
12866           uncompressed_size += start[8]; uncompressed_size <<= 8;
12867           uncompressed_size += start[9]; uncompressed_size <<= 8;
12868           uncompressed_size += start[10]; uncompressed_size <<= 8;
12869           uncompressed_size += start[11];
12870           start += 12;
12871           new_size -= 12;
12872         }
12873
12874       if (uncompressed_size)
12875         {
12876           if (uncompress_section_contents (& start,
12877                                            uncompressed_size, & new_size))
12878             num_bytes = new_size;
12879           else
12880             {
12881               error (_("Unable to decompress section %s\n"),
12882                      printable_section_name (section));
12883               return FALSE;
12884             }
12885         }
12886       else
12887         start = real_start;
12888     }
12889
12890   /* If the section being dumped has relocations against it the user might
12891      be expecting these relocations to have been applied.  Check for this
12892      case and issue a warning message in order to avoid confusion.
12893      FIXME: Maybe we ought to have an option that dumps a section with
12894      relocs applied ?  */
12895   for (relsec = section_headers;
12896        relsec < section_headers + elf_header.e_shnum;
12897        ++relsec)
12898     {
12899       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12900           || relsec->sh_info >= elf_header.e_shnum
12901           || section_headers + relsec->sh_info != section
12902           || relsec->sh_size == 0
12903           || relsec->sh_link >= elf_header.e_shnum)
12904         continue;
12905
12906       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12907       break;
12908     }
12909
12910   data = start;
12911   end  = start + num_bytes;
12912   some_strings_shown = FALSE;
12913
12914   while (data < end)
12915     {
12916       while (!ISPRINT (* data))
12917         if (++ data >= end)
12918           break;
12919
12920       if (data < end)
12921         {
12922           size_t maxlen = end - data;
12923
12924 #ifndef __MSVCRT__
12925           /* PR 11128: Use two separate invocations in order to work
12926              around bugs in the Solaris 8 implementation of printf.  */
12927           printf ("  [%6tx]  ", data - start);
12928 #else
12929           printf ("  [%6Ix]  ", (size_t) (data - start));
12930 #endif
12931           if (maxlen > 0)
12932             {
12933               print_symbol ((int) maxlen, (const char *) data);
12934               putchar ('\n');
12935               data += strnlen ((const char *) data, maxlen);
12936             }
12937           else
12938             {
12939               printf (_("<corrupt>\n"));
12940               data = end;
12941             }
12942           some_strings_shown = TRUE;
12943         }
12944     }
12945
12946   if (! some_strings_shown)
12947     printf (_("  No strings found in this section."));
12948
12949   free (real_start);
12950
12951   putchar ('\n');
12952   return TRUE;
12953 }
12954
12955 static bfd_boolean
12956 dump_section_as_bytes (Elf_Internal_Shdr * section,
12957                        FILE * file,
12958                        bfd_boolean relocate)
12959 {
12960   Elf_Internal_Shdr * relsec;
12961   bfd_size_type       bytes;
12962   bfd_size_type       section_size;
12963   bfd_vma             addr;
12964   unsigned char *     data;
12965   unsigned char *     real_start;
12966   unsigned char *     start;
12967
12968   real_start = start = (unsigned char *) get_section_contents (section, file);
12969   if (start == NULL)
12970     return FALSE;
12971
12972   section_size = section->sh_size;
12973
12974   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12975
12976   if (decompress_dumps)
12977     {
12978       dwarf_size_type new_size = section_size;
12979       dwarf_size_type uncompressed_size = 0;
12980
12981       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12982         {
12983           Elf_Internal_Chdr chdr;
12984           unsigned int compression_header_size
12985             = get_compression_header (& chdr, start, section_size);
12986
12987           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12988             {
12989               warn (_("section '%s' has unsupported compress type: %d\n"),
12990                     printable_section_name (section), chdr.ch_type);
12991               return FALSE;
12992             }
12993           else if (chdr.ch_addralign != section->sh_addralign)
12994             {
12995               warn (_("compressed section '%s' is corrupted\n"),
12996                     printable_section_name (section));
12997               return FALSE;
12998             }
12999           uncompressed_size = chdr.ch_size;
13000           start += compression_header_size;
13001           new_size -= compression_header_size;
13002         }
13003       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13004         {
13005           /* Read the zlib header.  In this case, it should be "ZLIB"
13006              followed by the uncompressed section size, 8 bytes in
13007              big-endian order.  */
13008           uncompressed_size = start[4]; uncompressed_size <<= 8;
13009           uncompressed_size += start[5]; uncompressed_size <<= 8;
13010           uncompressed_size += start[6]; uncompressed_size <<= 8;
13011           uncompressed_size += start[7]; uncompressed_size <<= 8;
13012           uncompressed_size += start[8]; uncompressed_size <<= 8;
13013           uncompressed_size += start[9]; uncompressed_size <<= 8;
13014           uncompressed_size += start[10]; uncompressed_size <<= 8;
13015           uncompressed_size += start[11];
13016           start += 12;
13017           new_size -= 12;
13018         }
13019
13020       if (uncompressed_size)
13021         {
13022           if (uncompress_section_contents (& start, uncompressed_size,
13023                                            & new_size))
13024             {
13025               section_size = new_size;
13026             }
13027           else
13028             {
13029               error (_("Unable to decompress section %s\n"),
13030                      printable_section_name (section));
13031               /* FIXME: Print the section anyway ?  */
13032               return FALSE;
13033             }
13034         }
13035       else
13036         start = real_start;
13037     }
13038
13039   if (relocate)
13040     {
13041       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13042         return FALSE;
13043     }
13044   else
13045     {
13046       /* If the section being dumped has relocations against it the user might
13047          be expecting these relocations to have been applied.  Check for this
13048          case and issue a warning message in order to avoid confusion.
13049          FIXME: Maybe we ought to have an option that dumps a section with
13050          relocs applied ?  */
13051       for (relsec = section_headers;
13052            relsec < section_headers + elf_header.e_shnum;
13053            ++relsec)
13054         {
13055           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13056               || relsec->sh_info >= elf_header.e_shnum
13057               || section_headers + relsec->sh_info != section
13058               || relsec->sh_size == 0
13059               || relsec->sh_link >= elf_header.e_shnum)
13060             continue;
13061
13062           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13063           break;
13064         }
13065     }
13066
13067   addr = section->sh_addr;
13068   bytes = section_size;
13069   data = start;
13070
13071   while (bytes)
13072     {
13073       int j;
13074       int k;
13075       int lbytes;
13076
13077       lbytes = (bytes > 16 ? 16 : bytes);
13078
13079       printf ("  0x%8.8lx ", (unsigned long) addr);
13080
13081       for (j = 0; j < 16; j++)
13082         {
13083           if (j < lbytes)
13084             printf ("%2.2x", data[j]);
13085           else
13086             printf ("  ");
13087
13088           if ((j & 3) == 3)
13089             printf (" ");
13090         }
13091
13092       for (j = 0; j < lbytes; j++)
13093         {
13094           k = data[j];
13095           if (k >= ' ' && k < 0x7f)
13096             printf ("%c", k);
13097           else
13098             printf (".");
13099         }
13100
13101       putchar ('\n');
13102
13103       data  += lbytes;
13104       addr  += lbytes;
13105       bytes -= lbytes;
13106     }
13107
13108   free (real_start);
13109
13110   putchar ('\n');
13111   return TRUE;
13112 }
13113
13114 static bfd_boolean
13115 load_specific_debug_section (enum dwarf_section_display_enum debug,
13116                              const Elf_Internal_Shdr * sec, void * file)
13117 {
13118   struct dwarf_section * section = &debug_displays [debug].section;
13119   char buf [64];
13120
13121   /* If it is already loaded, do nothing.  */
13122   if (section->start != NULL)
13123     return TRUE;
13124
13125   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13126   section->address = sec->sh_addr;
13127   section->user_data = NULL;
13128   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13129                                                sec->sh_offset, 1,
13130                                                sec->sh_size, buf);
13131   if (section->start == NULL)
13132     section->size = 0;
13133   else
13134     {
13135       unsigned char *start = section->start;
13136       dwarf_size_type size = sec->sh_size;
13137       dwarf_size_type uncompressed_size = 0;
13138
13139       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13140         {
13141           Elf_Internal_Chdr chdr;
13142           unsigned int compression_header_size;
13143
13144           if (size < (is_32bit_elf
13145                       ? sizeof (Elf32_External_Chdr)
13146                       : sizeof (Elf64_External_Chdr)))
13147             {
13148               warn (_("compressed section %s is too small to contain a compression header"),
13149                     section->name);
13150               return FALSE;
13151             }
13152
13153           compression_header_size = get_compression_header (&chdr, start, size);
13154
13155           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13156             {
13157               warn (_("section '%s' has unsupported compress type: %d\n"),
13158                     section->name, chdr.ch_type);
13159               return FALSE;
13160             }
13161           else if (chdr.ch_addralign != sec->sh_addralign)
13162             {
13163               warn (_("compressed section '%s' is corrupted\n"),
13164                     section->name);
13165               return FALSE;
13166             }
13167           uncompressed_size = chdr.ch_size;
13168           start += compression_header_size;
13169           size -= compression_header_size;
13170         }
13171       else if (size > 12 && streq ((char *) start, "ZLIB"))
13172         {
13173           /* Read the zlib header.  In this case, it should be "ZLIB"
13174              followed by the uncompressed section size, 8 bytes in
13175              big-endian order.  */
13176           uncompressed_size = start[4]; uncompressed_size <<= 8;
13177           uncompressed_size += start[5]; uncompressed_size <<= 8;
13178           uncompressed_size += start[6]; uncompressed_size <<= 8;
13179           uncompressed_size += start[7]; uncompressed_size <<= 8;
13180           uncompressed_size += start[8]; uncompressed_size <<= 8;
13181           uncompressed_size += start[9]; uncompressed_size <<= 8;
13182           uncompressed_size += start[10]; uncompressed_size <<= 8;
13183           uncompressed_size += start[11];
13184           start += 12;
13185           size -= 12;
13186         }
13187
13188       if (uncompressed_size)
13189         {
13190           if (uncompress_section_contents (&start, uncompressed_size,
13191                                            &size))
13192             {
13193               /* Free the compressed buffer, update the section buffer
13194                  and the section size if uncompress is successful.  */
13195               free (section->start);
13196               section->start = start;
13197             }
13198           else
13199             {
13200               error (_("Unable to decompress section %s\n"),
13201                      printable_section_name (sec));
13202               return FALSE;
13203             }
13204         }
13205
13206       section->size = size;
13207     }
13208
13209   if (section->start == NULL)
13210     return FALSE;
13211
13212   if (debug_displays [debug].relocate)
13213     {
13214       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13215                                & section->reloc_info, & section->num_relocs))
13216         return FALSE;
13217     }
13218   else
13219     {
13220       section->reloc_info = NULL;
13221       section->num_relocs = 0;
13222     }
13223
13224   return TRUE;
13225 }
13226
13227 /* If this is not NULL, load_debug_section will only look for sections
13228    within the list of sections given here.  */
13229 static unsigned int * section_subset = NULL;
13230
13231 bfd_boolean
13232 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13233 {
13234   struct dwarf_section * section = &debug_displays [debug].section;
13235   Elf_Internal_Shdr * sec;
13236
13237   /* Locate the debug section.  */
13238   sec = find_section_in_set (section->uncompressed_name, section_subset);
13239   if (sec != NULL)
13240     section->name = section->uncompressed_name;
13241   else
13242     {
13243       sec = find_section_in_set (section->compressed_name, section_subset);
13244       if (sec != NULL)
13245         section->name = section->compressed_name;
13246     }
13247   if (sec == NULL)
13248     return FALSE;
13249
13250   /* If we're loading from a subset of sections, and we've loaded
13251      a section matching this name before, it's likely that it's a
13252      different one.  */
13253   if (section_subset != NULL)
13254     free_debug_section (debug);
13255
13256   return load_specific_debug_section (debug, sec, (FILE *) file);
13257 }
13258
13259 void
13260 free_debug_section (enum dwarf_section_display_enum debug)
13261 {
13262   struct dwarf_section * section = &debug_displays [debug].section;
13263
13264   if (section->start == NULL)
13265     return;
13266
13267   free ((char *) section->start);
13268   section->start = NULL;
13269   section->address = 0;
13270   section->size = 0;
13271 }
13272
13273 static bfd_boolean
13274 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13275 {
13276   char * name = SECTION_NAME (section);
13277   const char * print_name = printable_section_name (section);
13278   bfd_size_type length;
13279   bfd_boolean result = TRUE;
13280   int i;
13281
13282   length = section->sh_size;
13283   if (length == 0)
13284     {
13285       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13286       return TRUE;
13287     }
13288   if (section->sh_type == SHT_NOBITS)
13289     {
13290       /* There is no point in dumping the contents of a debugging section
13291          which has the NOBITS type - the bits in the file will be random.
13292          This can happen when a file containing a .eh_frame section is
13293          stripped with the --only-keep-debug command line option.  */
13294       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13295               print_name);
13296       return FALSE;
13297     }
13298
13299   if (const_strneq (name, ".gnu.linkonce.wi."))
13300     name = ".debug_info";
13301
13302   /* See if we know how to display the contents of this section.  */
13303   for (i = 0; i < max; i++)
13304     if (streq (debug_displays[i].section.uncompressed_name, name)
13305         || (i == line && const_strneq (name, ".debug_line."))
13306         || streq (debug_displays[i].section.compressed_name, name))
13307       {
13308         struct dwarf_section * sec = &debug_displays [i].section;
13309         int secondary = (section != find_section (name));
13310
13311         if (secondary)
13312           free_debug_section ((enum dwarf_section_display_enum) i);
13313
13314         if (i == line && const_strneq (name, ".debug_line."))
13315           sec->name = name;
13316         else if (streq (sec->uncompressed_name, name))
13317           sec->name = sec->uncompressed_name;
13318         else
13319           sec->name = sec->compressed_name;
13320         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13321                                          section, file))
13322           {
13323             /* If this debug section is part of a CU/TU set in a .dwp file,
13324                restrict load_debug_section to the sections in that set.  */
13325             section_subset = find_cu_tu_set (file, shndx);
13326
13327             result &= debug_displays[i].display (sec, file);
13328
13329             section_subset = NULL;
13330
13331             if (secondary || (i != info && i != abbrev))
13332               free_debug_section ((enum dwarf_section_display_enum) i);
13333           }
13334
13335         break;
13336       }
13337
13338   if (i == max)
13339     {
13340       printf (_("Unrecognized debug section: %s\n"), print_name);
13341       result = FALSE;
13342     }
13343
13344   return result;
13345 }
13346
13347 /* Set DUMP_SECTS for all sections where dumps were requested
13348    based on section name.  */
13349
13350 static void
13351 initialise_dumps_byname (void)
13352 {
13353   struct dump_list_entry * cur;
13354
13355   for (cur = dump_sects_byname; cur; cur = cur->next)
13356     {
13357       unsigned int i;
13358       bfd_boolean any = FALSE;
13359
13360       for (i = 0; i < elf_header.e_shnum; i++)
13361         if (streq (SECTION_NAME (section_headers + i), cur->name))
13362           {
13363             request_dump_bynumber (i, cur->type);
13364             any = TRUE;
13365           }
13366
13367       if (!any)
13368         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13369               cur->name);
13370     }
13371 }
13372
13373 static bfd_boolean
13374 process_section_contents (FILE * file)
13375 {
13376   Elf_Internal_Shdr * section;
13377   unsigned int i;
13378   bfd_boolean res = TRUE;
13379
13380   if (! do_dump)
13381     return TRUE;
13382
13383   initialise_dumps_byname ();
13384
13385   for (i = 0, section = section_headers;
13386        i < elf_header.e_shnum && i < num_dump_sects;
13387        i++, section++)
13388     {
13389 #ifdef SUPPORT_DISASSEMBLY
13390       if (dump_sects[i] & DISASS_DUMP)
13391         disassemble_section (section, file);
13392 #endif
13393       if (dump_sects[i] & HEX_DUMP)
13394         {
13395           if (! dump_section_as_bytes (section, file, FALSE))
13396             res = FALSE;
13397         }
13398
13399       if (dump_sects[i] & RELOC_DUMP)
13400         {
13401           if (! dump_section_as_bytes (section, file, TRUE))
13402             res = FALSE;
13403         }
13404
13405       if (dump_sects[i] & STRING_DUMP)
13406         {
13407           if (! dump_section_as_strings (section, file))
13408             res = FALSE;
13409         }
13410
13411       if (dump_sects[i] & DEBUG_DUMP)
13412         {
13413           if (! display_debug_section (i, section, file))
13414             res = FALSE;
13415         }
13416     }
13417
13418   /* Check to see if the user requested a
13419      dump of a section that does not exist.  */
13420   while (i < num_dump_sects)
13421     {
13422       if (dump_sects[i])
13423         {
13424           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13425           res = FALSE;
13426         }
13427       i++;
13428     }
13429
13430   return res;
13431 }
13432
13433 static void
13434 process_mips_fpe_exception (int mask)
13435 {
13436   if (mask)
13437     {
13438       bfd_boolean first = TRUE;
13439
13440       if (mask & OEX_FPU_INEX)
13441         fputs ("INEX", stdout), first = FALSE;
13442       if (mask & OEX_FPU_UFLO)
13443         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13444       if (mask & OEX_FPU_OFLO)
13445         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13446       if (mask & OEX_FPU_DIV0)
13447         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13448       if (mask & OEX_FPU_INVAL)
13449         printf ("%sINVAL", first ? "" : "|");
13450     }
13451   else
13452     fputs ("0", stdout);
13453 }
13454
13455 /* Display's the value of TAG at location P.  If TAG is
13456    greater than 0 it is assumed to be an unknown tag, and
13457    a message is printed to this effect.  Otherwise it is
13458    assumed that a message has already been printed.
13459
13460    If the bottom bit of TAG is set it assumed to have a
13461    string value, otherwise it is assumed to have an integer
13462    value.
13463
13464    Returns an updated P pointing to the first unread byte
13465    beyond the end of TAG's value.
13466
13467    Reads at or beyond END will not be made.  */
13468
13469 static unsigned char *
13470 display_tag_value (signed int tag,
13471                    unsigned char * p,
13472                    const unsigned char * const end)
13473 {
13474   unsigned long val;
13475
13476   if (tag > 0)
13477     printf ("  Tag_unknown_%d: ", tag);
13478
13479   if (p >= end)
13480     {
13481       warn (_("<corrupt tag>\n"));
13482     }
13483   else if (tag & 1)
13484     {
13485       /* PR 17531 file: 027-19978-0.004.  */
13486       size_t maxlen = (end - p) - 1;
13487
13488       putchar ('"');
13489       if (maxlen > 0)
13490         {
13491           print_symbol ((int) maxlen, (const char *) p);
13492           p += strnlen ((char *) p, maxlen) + 1;
13493         }
13494       else
13495         {
13496           printf (_("<corrupt string tag>"));
13497           p = (unsigned char *) end;
13498         }
13499       printf ("\"\n");
13500     }
13501   else
13502     {
13503       unsigned int len;
13504
13505       val = read_uleb128 (p, &len, end);
13506       p += len;
13507       printf ("%ld (0x%lx)\n", val, val);
13508     }
13509
13510   assert (p <= end);
13511   return p;
13512 }
13513
13514 /* ARC ABI attributes section.  */
13515
13516 static unsigned char *
13517 display_arc_attribute (unsigned char * p,
13518                        const unsigned char * const end)
13519 {
13520   unsigned int tag;
13521   unsigned int len;
13522   unsigned int val;
13523
13524   tag = read_uleb128 (p, &len, end);
13525   p += len;
13526
13527   switch (tag)
13528     {
13529     case Tag_ARC_PCS_config:
13530       val = read_uleb128 (p, &len, end);
13531       p += len;
13532       printf ("  Tag_ARC_PCS_config: ");
13533       switch (val)
13534         {
13535         case 0:
13536           printf (_("Absent/Non standard\n"));
13537           break;
13538         case 1:
13539           printf (_("Bare metal/mwdt\n"));
13540           break;
13541         case 2:
13542           printf (_("Bare metal/newlib\n"));
13543           break;
13544         case 3:
13545           printf (_("Linux/uclibc\n"));
13546           break;
13547         case 4:
13548           printf (_("Linux/glibc\n"));
13549           break;
13550         default:
13551           printf (_("Unknown\n"));
13552           break;
13553         }
13554       break;
13555
13556     case Tag_ARC_CPU_base:
13557       val = read_uleb128 (p, &len, end);
13558       p += len;
13559       printf ("  Tag_ARC_CPU_base: ");
13560       switch (val)
13561         {
13562         default:
13563         case TAG_CPU_NONE:
13564           printf (_("Absent\n"));
13565           break;
13566         case TAG_CPU_ARC6xx:
13567           printf ("ARC6xx\n");
13568           break;
13569         case TAG_CPU_ARC7xx:
13570           printf ("ARC7xx\n");
13571           break;
13572         case TAG_CPU_ARCEM:
13573           printf ("ARCEM\n");
13574           break;
13575         case TAG_CPU_ARCHS:
13576           printf ("ARCHS\n");
13577           break;
13578         }
13579       break;
13580
13581     case Tag_ARC_CPU_variation:
13582       val = read_uleb128 (p, &len, end);
13583       p += len;
13584       printf ("  Tag_ARC_CPU_variation: ");
13585       switch (val)
13586         {
13587         default:
13588           if (val > 0 && val < 16)
13589               printf ("Core%d\n", val);
13590           else
13591               printf ("Unknown\n");
13592           break;
13593
13594         case 0:
13595           printf (_("Absent\n"));
13596           break;
13597         }
13598       break;
13599
13600     case Tag_ARC_CPU_name:
13601       printf ("  Tag_ARC_CPU_name: ");
13602       p = display_tag_value (-1, p, end);
13603       break;
13604
13605     case Tag_ARC_ABI_rf16:
13606       val = read_uleb128 (p, &len, end);
13607       p += len;
13608       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13609       break;
13610
13611     case Tag_ARC_ABI_osver:
13612       val = read_uleb128 (p, &len, end);
13613       p += len;
13614       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13615       break;
13616
13617     case Tag_ARC_ABI_pic:
13618     case Tag_ARC_ABI_sda:
13619       val = read_uleb128 (p, &len, end);
13620       p += len;
13621       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13622               : "  Tag_ARC_ABI_pic: ");
13623       switch (val)
13624         {
13625         case 0:
13626           printf (_("Absent\n"));
13627           break;
13628         case 1:
13629           printf ("MWDT\n");
13630           break;
13631         case 2:
13632           printf ("GNU\n");
13633           break;
13634         default:
13635           printf (_("Unknown\n"));
13636           break;
13637         }
13638       break;
13639
13640     case Tag_ARC_ABI_tls:
13641       val = read_uleb128 (p, &len, end);
13642       p += len;
13643       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13644       break;
13645
13646     case Tag_ARC_ABI_enumsize:
13647       val = read_uleb128 (p, &len, end);
13648       p += len;
13649       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13650               _("smallest"));
13651       break;
13652
13653     case Tag_ARC_ABI_exceptions:
13654       val = read_uleb128 (p, &len, end);
13655       p += len;
13656       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13657               : _("default"));
13658       break;
13659
13660     case Tag_ARC_ABI_double_size:
13661       val = read_uleb128 (p, &len, end);
13662       p += len;
13663       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13664       break;
13665
13666     case Tag_ARC_ISA_config:
13667       printf ("  Tag_ARC_ISA_config: ");
13668       p = display_tag_value (-1, p, end);
13669       break;
13670
13671     case Tag_ARC_ISA_apex:
13672       printf ("  Tag_ARC_ISA_apex: ");
13673       p = display_tag_value (-1, p, end);
13674       break;
13675
13676     case Tag_ARC_ISA_mpy_option:
13677       val = read_uleb128 (p, &len, end);
13678       p += len;
13679       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13680       break;
13681
13682     default:
13683       return display_tag_value (tag & 1, p, end);
13684     }
13685
13686   return p;
13687 }
13688
13689 /* ARM EABI attributes section.  */
13690 typedef struct
13691 {
13692   unsigned int tag;
13693   const char * name;
13694   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13695   unsigned int type;
13696   const char ** table;
13697 } arm_attr_public_tag;
13698
13699 static const char * arm_attr_tag_CPU_arch[] =
13700   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13701    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13702    "v8-M.mainline"};
13703 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13704 static const char * arm_attr_tag_THUMB_ISA_use[] =
13705   {"No", "Thumb-1", "Thumb-2", "Yes"};
13706 static const char * arm_attr_tag_FP_arch[] =
13707   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13708    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13709 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13710 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13711   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13712    "NEON for ARMv8.1"};
13713 static const char * arm_attr_tag_PCS_config[] =
13714   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13715    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13716 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13717   {"V6", "SB", "TLS", "Unused"};
13718 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13719   {"Absolute", "PC-relative", "SB-relative", "None"};
13720 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13721   {"Absolute", "PC-relative", "None"};
13722 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13723   {"None", "direct", "GOT-indirect"};
13724 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13725   {"None", "??? 1", "2", "??? 3", "4"};
13726 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13727 static const char * arm_attr_tag_ABI_FP_denormal[] =
13728   {"Unused", "Needed", "Sign only"};
13729 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13730 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13731 static const char * arm_attr_tag_ABI_FP_number_model[] =
13732   {"Unused", "Finite", "RTABI", "IEEE 754"};
13733 static const char * arm_attr_tag_ABI_enum_size[] =
13734   {"Unused", "small", "int", "forced to int"};
13735 static const char * arm_attr_tag_ABI_HardFP_use[] =
13736   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13737 static const char * arm_attr_tag_ABI_VFP_args[] =
13738   {"AAPCS", "VFP registers", "custom", "compatible"};
13739 static const char * arm_attr_tag_ABI_WMMX_args[] =
13740   {"AAPCS", "WMMX registers", "custom"};
13741 static const char * arm_attr_tag_ABI_optimization_goals[] =
13742   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13743     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13744 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13745   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13746     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13747 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13748 static const char * arm_attr_tag_FP_HP_extension[] =
13749   {"Not Allowed", "Allowed"};
13750 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13751   {"None", "IEEE 754", "Alternative Format"};
13752 static const char * arm_attr_tag_DSP_extension[] =
13753   {"Follow architecture", "Allowed"};
13754 static const char * arm_attr_tag_MPextension_use[] =
13755   {"Not Allowed", "Allowed"};
13756 static const char * arm_attr_tag_DIV_use[] =
13757   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13758     "Allowed in v7-A with integer division extension"};
13759 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13760 static const char * arm_attr_tag_Virtualization_use[] =
13761   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13762     "TrustZone and Virtualization Extensions"};
13763 static const char * arm_attr_tag_MPextension_use_legacy[] =
13764   {"Not Allowed", "Allowed"};
13765
13766 #define LOOKUP(id, name) \
13767   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13768 static arm_attr_public_tag arm_attr_public_tags[] =
13769 {
13770   {4, "CPU_raw_name", 1, NULL},
13771   {5, "CPU_name", 1, NULL},
13772   LOOKUP(6, CPU_arch),
13773   {7, "CPU_arch_profile", 0, NULL},
13774   LOOKUP(8, ARM_ISA_use),
13775   LOOKUP(9, THUMB_ISA_use),
13776   LOOKUP(10, FP_arch),
13777   LOOKUP(11, WMMX_arch),
13778   LOOKUP(12, Advanced_SIMD_arch),
13779   LOOKUP(13, PCS_config),
13780   LOOKUP(14, ABI_PCS_R9_use),
13781   LOOKUP(15, ABI_PCS_RW_data),
13782   LOOKUP(16, ABI_PCS_RO_data),
13783   LOOKUP(17, ABI_PCS_GOT_use),
13784   LOOKUP(18, ABI_PCS_wchar_t),
13785   LOOKUP(19, ABI_FP_rounding),
13786   LOOKUP(20, ABI_FP_denormal),
13787   LOOKUP(21, ABI_FP_exceptions),
13788   LOOKUP(22, ABI_FP_user_exceptions),
13789   LOOKUP(23, ABI_FP_number_model),
13790   {24, "ABI_align_needed", 0, NULL},
13791   {25, "ABI_align_preserved", 0, NULL},
13792   LOOKUP(26, ABI_enum_size),
13793   LOOKUP(27, ABI_HardFP_use),
13794   LOOKUP(28, ABI_VFP_args),
13795   LOOKUP(29, ABI_WMMX_args),
13796   LOOKUP(30, ABI_optimization_goals),
13797   LOOKUP(31, ABI_FP_optimization_goals),
13798   {32, "compatibility", 0, NULL},
13799   LOOKUP(34, CPU_unaligned_access),
13800   LOOKUP(36, FP_HP_extension),
13801   LOOKUP(38, ABI_FP_16bit_format),
13802   LOOKUP(42, MPextension_use),
13803   LOOKUP(44, DIV_use),
13804   LOOKUP(46, DSP_extension),
13805   {64, "nodefaults", 0, NULL},
13806   {65, "also_compatible_with", 0, NULL},
13807   LOOKUP(66, T2EE_use),
13808   {67, "conformance", 1, NULL},
13809   LOOKUP(68, Virtualization_use),
13810   LOOKUP(70, MPextension_use_legacy)
13811 };
13812 #undef LOOKUP
13813
13814 static unsigned char *
13815 display_arm_attribute (unsigned char * p,
13816                        const unsigned char * const end)
13817 {
13818   unsigned int tag;
13819   unsigned int len;
13820   unsigned int val;
13821   arm_attr_public_tag * attr;
13822   unsigned i;
13823   unsigned int type;
13824
13825   tag = read_uleb128 (p, &len, end);
13826   p += len;
13827   attr = NULL;
13828   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13829     {
13830       if (arm_attr_public_tags[i].tag == tag)
13831         {
13832           attr = &arm_attr_public_tags[i];
13833           break;
13834         }
13835     }
13836
13837   if (attr)
13838     {
13839       printf ("  Tag_%s: ", attr->name);
13840       switch (attr->type)
13841         {
13842         case 0:
13843           switch (tag)
13844             {
13845             case 7: /* Tag_CPU_arch_profile.  */
13846               val = read_uleb128 (p, &len, end);
13847               p += len;
13848               switch (val)
13849                 {
13850                 case 0: printf (_("None\n")); break;
13851                 case 'A': printf (_("Application\n")); break;
13852                 case 'R': printf (_("Realtime\n")); break;
13853                 case 'M': printf (_("Microcontroller\n")); break;
13854                 case 'S': printf (_("Application or Realtime\n")); break;
13855                 default: printf ("??? (%d)\n", val); break;
13856                 }
13857               break;
13858
13859             case 24: /* Tag_align_needed.  */
13860               val = read_uleb128 (p, &len, end);
13861               p += len;
13862               switch (val)
13863                 {
13864                 case 0: printf (_("None\n")); break;
13865                 case 1: printf (_("8-byte\n")); break;
13866                 case 2: printf (_("4-byte\n")); break;
13867                 case 3: printf ("??? 3\n"); break;
13868                 default:
13869                   if (val <= 12)
13870                     printf (_("8-byte and up to %d-byte extended\n"),
13871                             1 << val);
13872                   else
13873                     printf ("??? (%d)\n", val);
13874                   break;
13875                 }
13876               break;
13877
13878             case 25: /* Tag_align_preserved.  */
13879               val = read_uleb128 (p, &len, end);
13880               p += len;
13881               switch (val)
13882                 {
13883                 case 0: printf (_("None\n")); break;
13884                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13885                 case 2: printf (_("8-byte\n")); break;
13886                 case 3: printf ("??? 3\n"); break;
13887                 default:
13888                   if (val <= 12)
13889                     printf (_("8-byte and up to %d-byte extended\n"),
13890                             1 << val);
13891                   else
13892                     printf ("??? (%d)\n", val);
13893                   break;
13894                 }
13895               break;
13896
13897             case 32: /* Tag_compatibility.  */
13898               {
13899                 val = read_uleb128 (p, &len, end);
13900                 p += len;
13901                 printf (_("flag = %d, vendor = "), val);
13902                 if (p < end - 1)
13903                   {
13904                     size_t maxlen = (end - p) - 1;
13905
13906                     print_symbol ((int) maxlen, (const char *) p);
13907                     p += strnlen ((char *) p, maxlen) + 1;
13908                   }
13909                 else
13910                   {
13911                     printf (_("<corrupt>"));
13912                     p = (unsigned char *) end;
13913                   }
13914                 putchar ('\n');
13915               }
13916               break;
13917
13918             case 64: /* Tag_nodefaults.  */
13919               /* PR 17531: file: 001-505008-0.01.  */
13920               if (p < end)
13921                 p++;
13922               printf (_("True\n"));
13923               break;
13924
13925             case 65: /* Tag_also_compatible_with.  */
13926               val = read_uleb128 (p, &len, end);
13927               p += len;
13928               if (val == 6 /* Tag_CPU_arch.  */)
13929                 {
13930                   val = read_uleb128 (p, &len, end);
13931                   p += len;
13932                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13933                     printf ("??? (%d)\n", val);
13934                   else
13935                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13936                 }
13937               else
13938                 printf ("???\n");
13939               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13940                 ;
13941               break;
13942
13943             default:
13944               printf (_("<unknown: %d>\n"), tag);
13945               break;
13946             }
13947           return p;
13948
13949         case 1:
13950           return display_tag_value (-1, p, end);
13951         case 2:
13952           return display_tag_value (0, p, end);
13953
13954         default:
13955           assert (attr->type & 0x80);
13956           val = read_uleb128 (p, &len, end);
13957           p += len;
13958           type = attr->type & 0x7f;
13959           if (val >= type)
13960             printf ("??? (%d)\n", val);
13961           else
13962             printf ("%s\n", attr->table[val]);
13963           return p;
13964         }
13965     }
13966
13967   return display_tag_value (tag, p, end);
13968 }
13969
13970 static unsigned char *
13971 display_gnu_attribute (unsigned char * p,
13972                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13973                        const unsigned char * const end)
13974 {
13975   int tag;
13976   unsigned int len;
13977   unsigned int val;
13978
13979   tag = read_uleb128 (p, &len, end);
13980   p += len;
13981
13982   /* Tag_compatibility is the only generic GNU attribute defined at
13983      present.  */
13984   if (tag == 32)
13985     {
13986       val = read_uleb128 (p, &len, end);
13987       p += len;
13988
13989       printf (_("flag = %d, vendor = "), val);
13990       if (p == end)
13991         {
13992           printf (_("<corrupt>\n"));
13993           warn (_("corrupt vendor attribute\n"));
13994         }
13995       else
13996         {
13997           if (p < end - 1)
13998             {
13999               size_t maxlen = (end - p) - 1;
14000
14001               print_symbol ((int) maxlen, (const char *) p);
14002               p += strnlen ((char *) p, maxlen) + 1;
14003             }
14004           else
14005             {
14006               printf (_("<corrupt>"));
14007               p = (unsigned char *) end;
14008             }
14009           putchar ('\n');
14010         }
14011       return p;
14012     }
14013
14014   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14015     return display_proc_gnu_attribute (p, tag, end);
14016
14017   return display_tag_value (tag, p, end);
14018 }
14019
14020 static unsigned char *
14021 display_power_gnu_attribute (unsigned char * p,
14022                              unsigned int tag,
14023                              const unsigned char * const end)
14024 {
14025   unsigned int len;
14026   unsigned int val;
14027
14028   if (tag == Tag_GNU_Power_ABI_FP)
14029     {
14030       val = read_uleb128 (p, &len, end);
14031       p += len;
14032       printf ("  Tag_GNU_Power_ABI_FP: ");
14033       if (len == 0)
14034         {
14035           printf (_("<corrupt>\n"));
14036           return p;
14037         }
14038
14039       if (val > 15)
14040         printf ("(%#x), ", val);
14041
14042       switch (val & 3)
14043         {
14044         case 0:
14045           printf (_("unspecified hard/soft float, "));
14046           break;
14047         case 1:
14048           printf (_("hard float, "));
14049           break;
14050         case 2:
14051           printf (_("soft float, "));
14052           break;
14053         case 3:
14054           printf (_("single-precision hard float, "));
14055           break;
14056         }
14057
14058       switch (val & 0xC)
14059         {
14060         case 0:
14061           printf (_("unspecified long double\n"));
14062           break;
14063         case 4:
14064           printf (_("128-bit IBM long double\n"));
14065           break;
14066         case 8:
14067           printf (_("64-bit long double\n"));
14068           break;
14069         case 12:
14070           printf (_("128-bit IEEE long double\n"));
14071           break;
14072         }
14073       return p;
14074     }
14075
14076   if (tag == Tag_GNU_Power_ABI_Vector)
14077     {
14078       val = read_uleb128 (p, &len, end);
14079       p += len;
14080       printf ("  Tag_GNU_Power_ABI_Vector: ");
14081       if (len == 0)
14082         {
14083           printf (_("<corrupt>\n"));
14084           return p;
14085         }
14086
14087       if (val > 3)
14088         printf ("(%#x), ", val);
14089
14090       switch (val & 3)
14091         {
14092         case 0:
14093           printf (_("unspecified\n"));
14094           break;
14095         case 1:
14096           printf (_("generic\n"));
14097           break;
14098         case 2:
14099           printf ("AltiVec\n");
14100           break;
14101         case 3:
14102           printf ("SPE\n");
14103           break;
14104         }
14105       return p;
14106     }
14107
14108   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14109     {
14110       val = read_uleb128 (p, &len, end);
14111       p += len;
14112       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14113       if (len == 0)
14114         {
14115           printf (_("<corrupt>\n"));
14116           return p;
14117         }
14118
14119       if (val > 2)
14120         printf ("(%#x), ", val);
14121
14122       switch (val & 3)
14123         {
14124         case 0:
14125           printf (_("unspecified\n"));
14126           break;
14127         case 1:
14128           printf ("r3/r4\n");
14129           break;
14130         case 2:
14131           printf (_("memory\n"));
14132           break;
14133         case 3:
14134           printf ("???\n");
14135           break;
14136         }
14137       return p;
14138     }
14139
14140   return display_tag_value (tag & 1, p, end);
14141 }
14142
14143 static unsigned char *
14144 display_s390_gnu_attribute (unsigned char * p,
14145                             unsigned int tag,
14146                             const unsigned char * const end)
14147 {
14148   unsigned int len;
14149   int val;
14150
14151   if (tag == Tag_GNU_S390_ABI_Vector)
14152     {
14153       val = read_uleb128 (p, &len, end);
14154       p += len;
14155       printf ("  Tag_GNU_S390_ABI_Vector: ");
14156
14157       switch (val)
14158         {
14159         case 0:
14160           printf (_("any\n"));
14161           break;
14162         case 1:
14163           printf (_("software\n"));
14164           break;
14165         case 2:
14166           printf (_("hardware\n"));
14167           break;
14168         default:
14169           printf ("??? (%d)\n", val);
14170           break;
14171         }
14172       return p;
14173    }
14174
14175   return display_tag_value (tag & 1, p, end);
14176 }
14177
14178 static void
14179 display_sparc_hwcaps (unsigned int mask)
14180 {
14181   if (mask)
14182     {
14183       bfd_boolean first = TRUE;
14184
14185       if (mask & ELF_SPARC_HWCAP_MUL32)
14186         fputs ("mul32", stdout), first = FALSE;
14187       if (mask & ELF_SPARC_HWCAP_DIV32)
14188         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14189       if (mask & ELF_SPARC_HWCAP_FSMULD)
14190         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14191       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14192         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14193       if (mask & ELF_SPARC_HWCAP_POPC)
14194         printf ("%spopc", first ? "" : "|"), first = FALSE;
14195       if (mask & ELF_SPARC_HWCAP_VIS)
14196         printf ("%svis", first ? "" : "|"), first = FALSE;
14197       if (mask & ELF_SPARC_HWCAP_VIS2)
14198         printf ("%svis2", first ? "" : "|"), first = FALSE;
14199       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14200         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14201       if (mask & ELF_SPARC_HWCAP_FMAF)
14202         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14203       if (mask & ELF_SPARC_HWCAP_VIS3)
14204         printf ("%svis3", first ? "" : "|"), first = FALSE;
14205       if (mask & ELF_SPARC_HWCAP_HPC)
14206         printf ("%shpc", first ? "" : "|"), first = FALSE;
14207       if (mask & ELF_SPARC_HWCAP_RANDOM)
14208         printf ("%srandom", first ? "" : "|"), first = FALSE;
14209       if (mask & ELF_SPARC_HWCAP_TRANS)
14210         printf ("%strans", first ? "" : "|"), first = FALSE;
14211       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14212         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14213       if (mask & ELF_SPARC_HWCAP_IMA)
14214         printf ("%sima", first ? "" : "|"), first = FALSE;
14215       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14216         printf ("%scspare", first ? "" : "|"), first = FALSE;
14217     }
14218   else
14219     fputc ('0', stdout);
14220   fputc ('\n', stdout);
14221 }
14222
14223 static void
14224 display_sparc_hwcaps2 (unsigned int mask)
14225 {
14226   if (mask)
14227     {
14228       bfd_boolean first = TRUE;
14229
14230       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14231         fputs ("fjathplus", stdout), first = FALSE;
14232       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14233         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14234       if (mask & ELF_SPARC_HWCAP2_ADP)
14235         printf ("%sadp", first ? "" : "|"), first = FALSE;
14236       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14237         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14238       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14239         printf ("%smwait", first ? "" : "|"), first = FALSE;
14240       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14241         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14242       if (mask & ELF_SPARC_HWCAP2_XMONT)
14243         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14244       if (mask & ELF_SPARC_HWCAP2_NSEC)
14245         printf ("%snsec", first ? "" : "|"), first = FALSE;
14246       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14247         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14248       if (mask & ELF_SPARC_HWCAP2_FJDES)
14249         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14250       if (mask & ELF_SPARC_HWCAP2_FJAES)
14251         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14252     }
14253   else
14254     fputc ('0', stdout);
14255   fputc ('\n', stdout);
14256 }
14257
14258 static unsigned char *
14259 display_sparc_gnu_attribute (unsigned char * p,
14260                              unsigned int tag,
14261                              const unsigned char * const end)
14262 {
14263   unsigned int len;
14264   int val;
14265
14266   if (tag == Tag_GNU_Sparc_HWCAPS)
14267     {
14268       val = read_uleb128 (p, &len, end);
14269       p += len;
14270       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14271       display_sparc_hwcaps (val);
14272       return p;
14273     }
14274   if (tag == Tag_GNU_Sparc_HWCAPS2)
14275     {
14276       val = read_uleb128 (p, &len, end);
14277       p += len;
14278       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14279       display_sparc_hwcaps2 (val);
14280       return p;
14281     }
14282
14283   return display_tag_value (tag, p, end);
14284 }
14285
14286 static void
14287 print_mips_fp_abi_value (unsigned int val)
14288 {
14289   switch (val)
14290     {
14291     case Val_GNU_MIPS_ABI_FP_ANY:
14292       printf (_("Hard or soft float\n"));
14293       break;
14294     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14295       printf (_("Hard float (double precision)\n"));
14296       break;
14297     case Val_GNU_MIPS_ABI_FP_SINGLE:
14298       printf (_("Hard float (single precision)\n"));
14299       break;
14300     case Val_GNU_MIPS_ABI_FP_SOFT:
14301       printf (_("Soft float\n"));
14302       break;
14303     case Val_GNU_MIPS_ABI_FP_OLD_64:
14304       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14305       break;
14306     case Val_GNU_MIPS_ABI_FP_XX:
14307       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14308       break;
14309     case Val_GNU_MIPS_ABI_FP_64:
14310       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14311       break;
14312     case Val_GNU_MIPS_ABI_FP_64A:
14313       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14314       break;
14315     case Val_GNU_MIPS_ABI_FP_NAN2008:
14316       printf (_("NaN 2008 compatibility\n"));
14317       break;
14318     default:
14319       printf ("??? (%d)\n", val);
14320       break;
14321     }
14322 }
14323
14324 static unsigned char *
14325 display_mips_gnu_attribute (unsigned char * p,
14326                             unsigned int tag,
14327                             const unsigned char * const end)
14328 {
14329   if (tag == Tag_GNU_MIPS_ABI_FP)
14330     {
14331       unsigned int len;
14332       unsigned int val;
14333
14334       val = read_uleb128 (p, &len, end);
14335       p += len;
14336       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14337
14338       print_mips_fp_abi_value (val);
14339
14340       return p;
14341    }
14342
14343   if (tag == Tag_GNU_MIPS_ABI_MSA)
14344     {
14345       unsigned int len;
14346       unsigned int val;
14347
14348       val = read_uleb128 (p, &len, end);
14349       p += len;
14350       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14351
14352       switch (val)
14353         {
14354         case Val_GNU_MIPS_ABI_MSA_ANY:
14355           printf (_("Any MSA or not\n"));
14356           break;
14357         case Val_GNU_MIPS_ABI_MSA_128:
14358           printf (_("128-bit MSA\n"));
14359           break;
14360         default:
14361           printf ("??? (%d)\n", val);
14362           break;
14363         }
14364       return p;
14365     }
14366
14367   return display_tag_value (tag & 1, p, end);
14368 }
14369
14370 static unsigned char *
14371 display_tic6x_attribute (unsigned char * p,
14372                          const unsigned char * const end)
14373 {
14374   unsigned int tag;
14375   unsigned int len;
14376   int val;
14377
14378   tag = read_uleb128 (p, &len, end);
14379   p += len;
14380
14381   switch (tag)
14382     {
14383     case Tag_ISA:
14384       val = read_uleb128 (p, &len, end);
14385       p += len;
14386       printf ("  Tag_ISA: ");
14387
14388       switch (val)
14389         {
14390         case C6XABI_Tag_ISA_none:
14391           printf (_("None\n"));
14392           break;
14393         case C6XABI_Tag_ISA_C62X:
14394           printf ("C62x\n");
14395           break;
14396         case C6XABI_Tag_ISA_C67X:
14397           printf ("C67x\n");
14398           break;
14399         case C6XABI_Tag_ISA_C67XP:
14400           printf ("C67x+\n");
14401           break;
14402         case C6XABI_Tag_ISA_C64X:
14403           printf ("C64x\n");
14404           break;
14405         case C6XABI_Tag_ISA_C64XP:
14406           printf ("C64x+\n");
14407           break;
14408         case C6XABI_Tag_ISA_C674X:
14409           printf ("C674x\n");
14410           break;
14411         default:
14412           printf ("??? (%d)\n", val);
14413           break;
14414         }
14415       return p;
14416
14417     case Tag_ABI_wchar_t:
14418       val = read_uleb128 (p, &len, end);
14419       p += len;
14420       printf ("  Tag_ABI_wchar_t: ");
14421       switch (val)
14422         {
14423         case 0:
14424           printf (_("Not used\n"));
14425           break;
14426         case 1:
14427           printf (_("2 bytes\n"));
14428           break;
14429         case 2:
14430           printf (_("4 bytes\n"));
14431           break;
14432         default:
14433           printf ("??? (%d)\n", val);
14434           break;
14435         }
14436       return p;
14437
14438     case Tag_ABI_stack_align_needed:
14439       val = read_uleb128 (p, &len, end);
14440       p += len;
14441       printf ("  Tag_ABI_stack_align_needed: ");
14442       switch (val)
14443         {
14444         case 0:
14445           printf (_("8-byte\n"));
14446           break;
14447         case 1:
14448           printf (_("16-byte\n"));
14449           break;
14450         default:
14451           printf ("??? (%d)\n", val);
14452           break;
14453         }
14454       return p;
14455
14456     case Tag_ABI_stack_align_preserved:
14457       val = read_uleb128 (p, &len, end);
14458       p += len;
14459       printf ("  Tag_ABI_stack_align_preserved: ");
14460       switch (val)
14461         {
14462         case 0:
14463           printf (_("8-byte\n"));
14464           break;
14465         case 1:
14466           printf (_("16-byte\n"));
14467           break;
14468         default:
14469           printf ("??? (%d)\n", val);
14470           break;
14471         }
14472       return p;
14473
14474     case Tag_ABI_DSBT:
14475       val = read_uleb128 (p, &len, end);
14476       p += len;
14477       printf ("  Tag_ABI_DSBT: ");
14478       switch (val)
14479         {
14480         case 0:
14481           printf (_("DSBT addressing not used\n"));
14482           break;
14483         case 1:
14484           printf (_("DSBT addressing used\n"));
14485           break;
14486         default:
14487           printf ("??? (%d)\n", val);
14488           break;
14489         }
14490       return p;
14491
14492     case Tag_ABI_PID:
14493       val = read_uleb128 (p, &len, end);
14494       p += len;
14495       printf ("  Tag_ABI_PID: ");
14496       switch (val)
14497         {
14498         case 0:
14499           printf (_("Data addressing position-dependent\n"));
14500           break;
14501         case 1:
14502           printf (_("Data addressing position-independent, GOT near DP\n"));
14503           break;
14504         case 2:
14505           printf (_("Data addressing position-independent, GOT far from DP\n"));
14506           break;
14507         default:
14508           printf ("??? (%d)\n", val);
14509           break;
14510         }
14511       return p;
14512
14513     case Tag_ABI_PIC:
14514       val = read_uleb128 (p, &len, end);
14515       p += len;
14516       printf ("  Tag_ABI_PIC: ");
14517       switch (val)
14518         {
14519         case 0:
14520           printf (_("Code addressing position-dependent\n"));
14521           break;
14522         case 1:
14523           printf (_("Code addressing position-independent\n"));
14524           break;
14525         default:
14526           printf ("??? (%d)\n", val);
14527           break;
14528         }
14529       return p;
14530
14531     case Tag_ABI_array_object_alignment:
14532       val = read_uleb128 (p, &len, end);
14533       p += len;
14534       printf ("  Tag_ABI_array_object_alignment: ");
14535       switch (val)
14536         {
14537         case 0:
14538           printf (_("8-byte\n"));
14539           break;
14540         case 1:
14541           printf (_("4-byte\n"));
14542           break;
14543         case 2:
14544           printf (_("16-byte\n"));
14545           break;
14546         default:
14547           printf ("??? (%d)\n", val);
14548           break;
14549         }
14550       return p;
14551
14552     case Tag_ABI_array_object_align_expected:
14553       val = read_uleb128 (p, &len, end);
14554       p += len;
14555       printf ("  Tag_ABI_array_object_align_expected: ");
14556       switch (val)
14557         {
14558         case 0:
14559           printf (_("8-byte\n"));
14560           break;
14561         case 1:
14562           printf (_("4-byte\n"));
14563           break;
14564         case 2:
14565           printf (_("16-byte\n"));
14566           break;
14567         default:
14568           printf ("??? (%d)\n", val);
14569           break;
14570         }
14571       return p;
14572
14573     case Tag_ABI_compatibility:
14574       {
14575         val = read_uleb128 (p, &len, end);
14576         p += len;
14577         printf ("  Tag_ABI_compatibility: ");
14578         printf (_("flag = %d, vendor = "), val);
14579         if (p < end - 1)
14580           {
14581             size_t maxlen = (end - p) - 1;
14582
14583             print_symbol ((int) maxlen, (const char *) p);
14584             p += strnlen ((char *) p, maxlen) + 1;
14585           }
14586         else
14587           {
14588             printf (_("<corrupt>"));
14589             p = (unsigned char *) end;
14590           }
14591         putchar ('\n');
14592         return p;
14593       }
14594
14595     case Tag_ABI_conformance:
14596       {
14597         printf ("  Tag_ABI_conformance: \"");
14598         if (p < end - 1)
14599           {
14600             size_t maxlen = (end - p) - 1;
14601
14602             print_symbol ((int) maxlen, (const char *) p);
14603             p += strnlen ((char *) p, maxlen) + 1;
14604           }
14605         else
14606           {
14607             printf (_("<corrupt>"));
14608             p = (unsigned char *) end;
14609           }
14610         printf ("\"\n");
14611         return p;
14612       }
14613     }
14614
14615   return display_tag_value (tag, p, end);
14616 }
14617
14618 static void
14619 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14620 {
14621   unsigned long addr = 0;
14622   size_t bytes = end - p;
14623
14624   assert (end > p);
14625   while (bytes)
14626     {
14627       int j;
14628       int k;
14629       int lbytes = (bytes > 16 ? 16 : bytes);
14630
14631       printf ("  0x%8.8lx ", addr);
14632
14633       for (j = 0; j < 16; j++)
14634         {
14635           if (j < lbytes)
14636             printf ("%2.2x", p[j]);
14637           else
14638             printf ("  ");
14639
14640           if ((j & 3) == 3)
14641             printf (" ");
14642         }
14643
14644       for (j = 0; j < lbytes; j++)
14645         {
14646           k = p[j];
14647           if (k >= ' ' && k < 0x7f)
14648             printf ("%c", k);
14649           else
14650             printf (".");
14651         }
14652
14653       putchar ('\n');
14654
14655       p  += lbytes;
14656       bytes -= lbytes;
14657       addr += lbytes;
14658     }
14659
14660   putchar ('\n');
14661 }
14662
14663 static unsigned char *
14664 display_msp430x_attribute (unsigned char * p,
14665                            const unsigned char * const end)
14666 {
14667   unsigned int len;
14668   unsigned int val;
14669   unsigned int tag;
14670
14671   tag = read_uleb128 (p, & len, end);
14672   p += len;
14673
14674   switch (tag)
14675     {
14676     case OFBA_MSPABI_Tag_ISA:
14677       val = read_uleb128 (p, &len, end);
14678       p += len;
14679       printf ("  Tag_ISA: ");
14680       switch (val)
14681         {
14682         case 0: printf (_("None\n")); break;
14683         case 1: printf (_("MSP430\n")); break;
14684         case 2: printf (_("MSP430X\n")); break;
14685         default: printf ("??? (%d)\n", val); break;
14686         }
14687       break;
14688
14689     case OFBA_MSPABI_Tag_Code_Model:
14690       val = read_uleb128 (p, &len, end);
14691       p += len;
14692       printf ("  Tag_Code_Model: ");
14693       switch (val)
14694         {
14695         case 0: printf (_("None\n")); break;
14696         case 1: printf (_("Small\n")); break;
14697         case 2: printf (_("Large\n")); break;
14698         default: printf ("??? (%d)\n", val); break;
14699         }
14700       break;
14701
14702     case OFBA_MSPABI_Tag_Data_Model:
14703       val = read_uleb128 (p, &len, end);
14704       p += len;
14705       printf ("  Tag_Data_Model: ");
14706       switch (val)
14707         {
14708         case 0: printf (_("None\n")); break;
14709         case 1: printf (_("Small\n")); break;
14710         case 2: printf (_("Large\n")); break;
14711         case 3: printf (_("Restricted Large\n")); break;
14712         default: printf ("??? (%d)\n", val); break;
14713         }
14714       break;
14715
14716     default:
14717       printf (_("  <unknown tag %d>: "), tag);
14718
14719       if (tag & 1)
14720         {
14721           putchar ('"');
14722           if (p < end - 1)
14723             {
14724               size_t maxlen = (end - p) - 1;
14725
14726               print_symbol ((int) maxlen, (const char *) p);
14727               p += strnlen ((char *) p, maxlen) + 1;
14728             }
14729           else
14730             {
14731               printf (_("<corrupt>"));
14732               p = (unsigned char *) end;
14733             }
14734           printf ("\"\n");
14735         }
14736       else
14737         {
14738           val = read_uleb128 (p, &len, end);
14739           p += len;
14740           printf ("%d (0x%x)\n", val, val);
14741         }
14742       break;
14743    }
14744
14745   assert (p <= end);
14746   return p;
14747 }
14748
14749 static bfd_boolean
14750 process_attributes (FILE * file,
14751                     const char * public_name,
14752                     unsigned int proc_type,
14753                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14754                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14755 {
14756   Elf_Internal_Shdr * sect;
14757   unsigned i;
14758   bfd_boolean res = TRUE;
14759
14760   /* Find the section header so that we get the size.  */
14761   for (i = 0, sect = section_headers;
14762        i < elf_header.e_shnum;
14763        i++, sect++)
14764     {
14765       unsigned char * contents;
14766       unsigned char * p;
14767
14768       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14769         continue;
14770
14771       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14772                                              sect->sh_size, _("attributes"));
14773       if (contents == NULL)
14774         {
14775           res = FALSE;
14776           continue;
14777         }
14778
14779       p = contents;
14780       /* The first character is the version of the attributes.
14781          Currently only version 1, (aka 'A') is recognised here.  */
14782       if (*p != 'A')
14783         {
14784           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14785           res = FALSE;
14786         }
14787       else
14788         {
14789           bfd_vma section_len;
14790
14791           section_len = sect->sh_size - 1;
14792           p++;
14793
14794           while (section_len > 0)
14795             {
14796               bfd_vma attr_len;
14797               unsigned int namelen;
14798               bfd_boolean public_section;
14799               bfd_boolean gnu_section;
14800
14801               if (section_len <= 4)
14802                 {
14803                   error (_("Tag section ends prematurely\n"));
14804                   res = FALSE;
14805                   break;
14806                 }
14807               attr_len = byte_get (p, 4);
14808               p += 4;
14809
14810               if (attr_len > section_len)
14811                 {
14812                   error (_("Bad attribute length (%u > %u)\n"),
14813                           (unsigned) attr_len, (unsigned) section_len);
14814                   attr_len = section_len;
14815                   res = FALSE;
14816                 }
14817               /* PR 17531: file: 001-101425-0.004  */
14818               else if (attr_len < 5)
14819                 {
14820                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14821                   res = FALSE;
14822                   break;
14823                 }
14824
14825               section_len -= attr_len;
14826               attr_len -= 4;
14827
14828               namelen = strnlen ((char *) p, attr_len) + 1;
14829               if (namelen == 0 || namelen >= attr_len)
14830                 {
14831                   error (_("Corrupt attribute section name\n"));
14832                   res = FALSE;
14833                   break;
14834                 }
14835
14836               printf (_("Attribute Section: "));
14837               print_symbol (INT_MAX, (const char *) p);
14838               putchar ('\n');
14839
14840               if (public_name && streq ((char *) p, public_name))
14841                 public_section = TRUE;
14842               else
14843                 public_section = FALSE;
14844
14845               if (streq ((char *) p, "gnu"))
14846                 gnu_section = TRUE;
14847               else
14848                 gnu_section = FALSE;
14849
14850               p += namelen;
14851               attr_len -= namelen;
14852
14853               while (attr_len > 0 && p < contents + sect->sh_size)
14854                 {
14855                   int tag;
14856                   int val;
14857                   bfd_vma size;
14858                   unsigned char * end;
14859
14860                   /* PR binutils/17531: Safe handling of corrupt files.  */
14861                   if (attr_len < 6)
14862                     {
14863                       error (_("Unused bytes at end of section\n"));
14864                       res = FALSE;
14865                       section_len = 0;
14866                       break;
14867                     }
14868
14869                   tag = *(p++);
14870                   size = byte_get (p, 4);
14871                   if (size > attr_len)
14872                     {
14873                       error (_("Bad subsection length (%u > %u)\n"),
14874                               (unsigned) size, (unsigned) attr_len);
14875                       res = FALSE;
14876                       size = attr_len;
14877                     }
14878                   /* PR binutils/17531: Safe handling of corrupt files.  */
14879                   if (size < 6)
14880                     {
14881                       error (_("Bad subsection length (%u < 6)\n"),
14882                               (unsigned) size);
14883                       res = FALSE;
14884                       section_len = 0;
14885                       break;
14886                     }
14887
14888                   attr_len -= size;
14889                   end = p + size - 1;
14890                   assert (end <= contents + sect->sh_size);
14891                   p += 4;
14892
14893                   switch (tag)
14894                     {
14895                     case 1:
14896                       printf (_("File Attributes\n"));
14897                       break;
14898                     case 2:
14899                       printf (_("Section Attributes:"));
14900                       goto do_numlist;
14901                     case 3:
14902                       printf (_("Symbol Attributes:"));
14903                       /* Fall through.  */
14904                     do_numlist:
14905                       for (;;)
14906                         {
14907                           unsigned int j;
14908
14909                           val = read_uleb128 (p, &j, end);
14910                           p += j;
14911                           if (val == 0)
14912                             break;
14913                           printf (" %d", val);
14914                         }
14915                       printf ("\n");
14916                       break;
14917                     default:
14918                       printf (_("Unknown tag: %d\n"), tag);
14919                       public_section = FALSE;
14920                       break;
14921                     }
14922
14923                   if (public_section && display_pub_attribute != NULL)
14924                     {
14925                       while (p < end)
14926                         p = display_pub_attribute (p, end);
14927                       assert (p == end);
14928                     }
14929                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14930                     {
14931                       while (p < end)
14932                         p = display_gnu_attribute (p,
14933                                                    display_proc_gnu_attribute,
14934                                                    end);
14935                       assert (p == end);
14936                     }
14937                   else if (p < end)
14938                     {
14939                       printf (_("  Unknown attribute:\n"));
14940                       display_raw_attribute (p, end);
14941                       p = end;
14942                     }
14943                   else
14944                     attr_len = 0;
14945                 }
14946             }
14947         }
14948
14949       free (contents);
14950     }
14951
14952   return res;
14953 }
14954
14955 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14956    Print the Address, Access and Initial fields of an entry at VMA ADDR
14957    and return the VMA of the next entry, or -1 if there was a problem.
14958    Does not read from DATA_END or beyond.  */
14959
14960 static bfd_vma
14961 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14962                       unsigned char * data_end)
14963 {
14964   printf ("  ");
14965   print_vma (addr, LONG_HEX);
14966   printf (" ");
14967   if (addr < pltgot + 0xfff0)
14968     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14969   else
14970     printf ("%10s", "");
14971   printf (" ");
14972   if (data == NULL)
14973     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14974   else
14975     {
14976       bfd_vma entry;
14977       unsigned char * from = data + addr - pltgot;
14978
14979       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14980         {
14981           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14982           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14983           return (bfd_vma) -1;
14984         }
14985       else
14986         {
14987           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14988           print_vma (entry, LONG_HEX);
14989         }
14990     }
14991   return addr + (is_32bit_elf ? 4 : 8);
14992 }
14993
14994 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14995    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14996    ADDR and return the VMA of the next entry.  */
14997
14998 static bfd_vma
14999 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15000 {
15001   printf ("  ");
15002   print_vma (addr, LONG_HEX);
15003   printf (" ");
15004   if (data == NULL)
15005     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15006   else
15007     {
15008       bfd_vma entry;
15009
15010       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15011       print_vma (entry, LONG_HEX);
15012     }
15013   return addr + (is_32bit_elf ? 4 : 8);
15014 }
15015
15016 static void
15017 print_mips_ases (unsigned int mask)
15018 {
15019   if (mask & AFL_ASE_DSP)
15020     fputs ("\n\tDSP ASE", stdout);
15021   if (mask & AFL_ASE_DSPR2)
15022     fputs ("\n\tDSP R2 ASE", stdout);
15023   if (mask & AFL_ASE_DSPR3)
15024     fputs ("\n\tDSP R3 ASE", stdout);
15025   if (mask & AFL_ASE_EVA)
15026     fputs ("\n\tEnhanced VA Scheme", stdout);
15027   if (mask & AFL_ASE_MCU)
15028     fputs ("\n\tMCU (MicroController) ASE", stdout);
15029   if (mask & AFL_ASE_MDMX)
15030     fputs ("\n\tMDMX ASE", stdout);
15031   if (mask & AFL_ASE_MIPS3D)
15032     fputs ("\n\tMIPS-3D ASE", stdout);
15033   if (mask & AFL_ASE_MT)
15034     fputs ("\n\tMT ASE", stdout);
15035   if (mask & AFL_ASE_SMARTMIPS)
15036     fputs ("\n\tSmartMIPS ASE", stdout);
15037   if (mask & AFL_ASE_VIRT)
15038     fputs ("\n\tVZ ASE", stdout);
15039   if (mask & AFL_ASE_MSA)
15040     fputs ("\n\tMSA ASE", stdout);
15041   if (mask & AFL_ASE_MIPS16)
15042     fputs ("\n\tMIPS16 ASE", stdout);
15043   if (mask & AFL_ASE_MICROMIPS)
15044     fputs ("\n\tMICROMIPS ASE", stdout);
15045   if (mask & AFL_ASE_XPA)
15046     fputs ("\n\tXPA ASE", stdout);
15047   if (mask & AFL_ASE_MIPS16E2)
15048     fputs ("\n\tMIPS16e2 ASE", stdout);
15049   if (mask == 0)
15050     fprintf (stdout, "\n\t%s", _("None"));
15051   else if ((mask & ~AFL_ASE_MASK) != 0)
15052     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15053 }
15054
15055 static void
15056 print_mips_isa_ext (unsigned int isa_ext)
15057 {
15058   switch (isa_ext)
15059     {
15060     case 0:
15061       fputs (_("None"), stdout);
15062       break;
15063     case AFL_EXT_XLR:
15064       fputs ("RMI XLR", stdout);
15065       break;
15066     case AFL_EXT_OCTEON3:
15067       fputs ("Cavium Networks Octeon3", stdout);
15068       break;
15069     case AFL_EXT_OCTEON2:
15070       fputs ("Cavium Networks Octeon2", stdout);
15071       break;
15072     case AFL_EXT_OCTEONP:
15073       fputs ("Cavium Networks OcteonP", stdout);
15074       break;
15075     case AFL_EXT_LOONGSON_3A:
15076       fputs ("Loongson 3A", stdout);
15077       break;
15078     case AFL_EXT_OCTEON:
15079       fputs ("Cavium Networks Octeon", stdout);
15080       break;
15081     case AFL_EXT_5900:
15082       fputs ("Toshiba R5900", stdout);
15083       break;
15084     case AFL_EXT_4650:
15085       fputs ("MIPS R4650", stdout);
15086       break;
15087     case AFL_EXT_4010:
15088       fputs ("LSI R4010", stdout);
15089       break;
15090     case AFL_EXT_4100:
15091       fputs ("NEC VR4100", stdout);
15092       break;
15093     case AFL_EXT_3900:
15094       fputs ("Toshiba R3900", stdout);
15095       break;
15096     case AFL_EXT_10000:
15097       fputs ("MIPS R10000", stdout);
15098       break;
15099     case AFL_EXT_SB1:
15100       fputs ("Broadcom SB-1", stdout);
15101       break;
15102     case AFL_EXT_4111:
15103       fputs ("NEC VR4111/VR4181", stdout);
15104       break;
15105     case AFL_EXT_4120:
15106       fputs ("NEC VR4120", stdout);
15107       break;
15108     case AFL_EXT_5400:
15109       fputs ("NEC VR5400", stdout);
15110       break;
15111     case AFL_EXT_5500:
15112       fputs ("NEC VR5500", stdout);
15113       break;
15114     case AFL_EXT_LOONGSON_2E:
15115       fputs ("ST Microelectronics Loongson 2E", stdout);
15116       break;
15117     case AFL_EXT_LOONGSON_2F:
15118       fputs ("ST Microelectronics Loongson 2F", stdout);
15119       break;
15120     default:
15121       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15122     }
15123 }
15124
15125 static signed int
15126 get_mips_reg_size (int reg_size)
15127 {
15128   return (reg_size == AFL_REG_NONE) ? 0
15129          : (reg_size == AFL_REG_32) ? 32
15130          : (reg_size == AFL_REG_64) ? 64
15131          : (reg_size == AFL_REG_128) ? 128
15132          : -1;
15133 }
15134
15135 static bfd_boolean
15136 process_mips_specific (FILE * file)
15137 {
15138   Elf_Internal_Dyn * entry;
15139   Elf_Internal_Shdr *sect = NULL;
15140   size_t liblist_offset = 0;
15141   size_t liblistno = 0;
15142   size_t conflictsno = 0;
15143   size_t options_offset = 0;
15144   size_t conflicts_offset = 0;
15145   size_t pltrelsz = 0;
15146   size_t pltrel = 0;
15147   bfd_vma pltgot = 0;
15148   bfd_vma mips_pltgot = 0;
15149   bfd_vma jmprel = 0;
15150   bfd_vma local_gotno = 0;
15151   bfd_vma gotsym = 0;
15152   bfd_vma symtabno = 0;
15153   bfd_boolean res = TRUE;
15154
15155   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15156                             display_mips_gnu_attribute))
15157     res = FALSE;
15158
15159   sect = find_section (".MIPS.abiflags");
15160
15161   if (sect != NULL)
15162     {
15163       Elf_External_ABIFlags_v0 *abiflags_ext;
15164       Elf_Internal_ABIFlags_v0 abiflags_in;
15165
15166       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15167         {
15168           error (_("Corrupt MIPS ABI Flags section.\n"));
15169           res = FALSE;
15170         }
15171       else
15172         {
15173           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15174                                    sect->sh_size, _("MIPS ABI Flags section"));
15175           if (abiflags_ext)
15176             {
15177               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15178               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15179               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15180               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15181               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15182               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15183               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15184               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15185               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15186               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15187               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15188
15189               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15190               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15191               if (abiflags_in.isa_rev > 1)
15192                 printf ("r%d", abiflags_in.isa_rev);
15193               printf ("\nGPR size: %d",
15194                       get_mips_reg_size (abiflags_in.gpr_size));
15195               printf ("\nCPR1 size: %d",
15196                       get_mips_reg_size (abiflags_in.cpr1_size));
15197               printf ("\nCPR2 size: %d",
15198                       get_mips_reg_size (abiflags_in.cpr2_size));
15199               fputs ("\nFP ABI: ", stdout);
15200               print_mips_fp_abi_value (abiflags_in.fp_abi);
15201               fputs ("ISA Extension: ", stdout);
15202               print_mips_isa_ext (abiflags_in.isa_ext);
15203               fputs ("\nASEs:", stdout);
15204               print_mips_ases (abiflags_in.ases);
15205               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15206               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15207               fputc ('\n', stdout);
15208               free (abiflags_ext);
15209             }
15210         }
15211     }
15212
15213   /* We have a lot of special sections.  Thanks SGI!  */
15214   if (dynamic_section == NULL)
15215     {
15216       /* No dynamic information available.  See if there is static GOT.  */
15217       sect = find_section (".got");
15218       if (sect != NULL)
15219         {
15220           unsigned char *data_end;
15221           unsigned char *data;
15222           bfd_vma ent, end;
15223           int addr_size;
15224
15225           pltgot = sect->sh_addr;
15226
15227           ent = pltgot;
15228           addr_size = (is_32bit_elf ? 4 : 8);
15229           end = pltgot + sect->sh_size;
15230
15231           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15232                                              end - pltgot, 1,
15233                                              _("Global Offset Table data"));
15234           /* PR 12855: Null data is handled gracefully throughout.  */
15235           data_end = data + (end - pltgot);
15236
15237           printf (_("\nStatic GOT:\n"));
15238           printf (_(" Canonical gp value: "));
15239           print_vma (ent + 0x7ff0, LONG_HEX);
15240           printf ("\n\n");
15241
15242           /* In a dynamic binary GOT[0] is reserved for the dynamic
15243              loader to store the lazy resolver pointer, however in
15244              a static binary it may well have been omitted and GOT
15245              reduced to a table of addresses.
15246              PR 21344: Check for the entry being fully available
15247              before fetching it.  */
15248           if (data
15249               && data + ent - pltgot + addr_size <= data_end
15250               && byte_get (data + ent - pltgot, addr_size) == 0)
15251             {
15252               printf (_(" Reserved entries:\n"));
15253               printf (_("  %*s %10s %*s\n"),
15254                       addr_size * 2, _("Address"), _("Access"),
15255                       addr_size * 2, _("Value"));
15256               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15257               printf ("\n");
15258               if (ent == (bfd_vma) -1)
15259                 goto sgot_print_fail;
15260
15261               /* Check for the MSB of GOT[1] being set, identifying a
15262                  GNU object.  This entry will be used by some runtime
15263                  loaders, to store the module pointer.  Otherwise this
15264                  is an ordinary local entry.
15265                  PR 21344: Check for the entry being fully available
15266                  before fetching it.  */
15267               if (data
15268                   && data + ent - pltgot + addr_size <= data_end
15269                   && (byte_get (data + ent - pltgot, addr_size)
15270                       >> (addr_size * 8 - 1)) != 0)
15271                 {
15272                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15273                   printf ("\n");
15274                   if (ent == (bfd_vma) -1)
15275                     goto sgot_print_fail;
15276                 }
15277               printf ("\n");
15278             }
15279
15280           if (ent < end)
15281             {
15282               printf (_(" Local entries:\n"));
15283               printf ("  %*s %10s %*s\n",
15284                       addr_size * 2, _("Address"), _("Access"),
15285                       addr_size * 2, _("Value"));
15286               while (ent < end)
15287                 {
15288                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15289                   printf ("\n");
15290                   if (ent == (bfd_vma) -1)
15291                     goto sgot_print_fail;
15292                 }
15293               printf ("\n");
15294             }
15295
15296         sgot_print_fail:
15297           if (data)
15298             free (data);
15299         }
15300       return res;
15301     }
15302
15303   for (entry = dynamic_section;
15304        /* PR 17531 file: 012-50589-0.004.  */
15305        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15306        ++entry)
15307     switch (entry->d_tag)
15308       {
15309       case DT_MIPS_LIBLIST:
15310         liblist_offset
15311           = offset_from_vma (file, entry->d_un.d_val,
15312                              liblistno * sizeof (Elf32_External_Lib));
15313         break;
15314       case DT_MIPS_LIBLISTNO:
15315         liblistno = entry->d_un.d_val;
15316         break;
15317       case DT_MIPS_OPTIONS:
15318         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15319         break;
15320       case DT_MIPS_CONFLICT:
15321         conflicts_offset
15322           = offset_from_vma (file, entry->d_un.d_val,
15323                              conflictsno * sizeof (Elf32_External_Conflict));
15324         break;
15325       case DT_MIPS_CONFLICTNO:
15326         conflictsno = entry->d_un.d_val;
15327         break;
15328       case DT_PLTGOT:
15329         pltgot = entry->d_un.d_ptr;
15330         break;
15331       case DT_MIPS_LOCAL_GOTNO:
15332         local_gotno = entry->d_un.d_val;
15333         break;
15334       case DT_MIPS_GOTSYM:
15335         gotsym = entry->d_un.d_val;
15336         break;
15337       case DT_MIPS_SYMTABNO:
15338         symtabno = entry->d_un.d_val;
15339         break;
15340       case DT_MIPS_PLTGOT:
15341         mips_pltgot = entry->d_un.d_ptr;
15342         break;
15343       case DT_PLTREL:
15344         pltrel = entry->d_un.d_val;
15345         break;
15346       case DT_PLTRELSZ:
15347         pltrelsz = entry->d_un.d_val;
15348         break;
15349       case DT_JMPREL:
15350         jmprel = entry->d_un.d_ptr;
15351         break;
15352       default:
15353         break;
15354       }
15355
15356   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15357     {
15358       Elf32_External_Lib * elib;
15359       size_t cnt;
15360
15361       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15362                                               liblistno,
15363                                               sizeof (Elf32_External_Lib),
15364                                               _("liblist section data"));
15365       if (elib)
15366         {
15367           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15368                   (unsigned long) liblistno);
15369           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15370                  stdout);
15371
15372           for (cnt = 0; cnt < liblistno; ++cnt)
15373             {
15374               Elf32_Lib liblist;
15375               time_t atime;
15376               char timebuf[128];
15377               struct tm * tmp;
15378
15379               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15380               atime = BYTE_GET (elib[cnt].l_time_stamp);
15381               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15382               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15383               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15384
15385               tmp = gmtime (&atime);
15386               snprintf (timebuf, sizeof (timebuf),
15387                         "%04u-%02u-%02uT%02u:%02u:%02u",
15388                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15389                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15390
15391               printf ("%3lu: ", (unsigned long) cnt);
15392               if (VALID_DYNAMIC_NAME (liblist.l_name))
15393                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15394               else
15395                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15396               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15397                       liblist.l_version);
15398
15399               if (liblist.l_flags == 0)
15400                 puts (_(" NONE"));
15401               else
15402                 {
15403                   static const struct
15404                   {
15405                     const char * name;
15406                     int bit;
15407                   }
15408                   l_flags_vals[] =
15409                   {
15410                     { " EXACT_MATCH", LL_EXACT_MATCH },
15411                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15412                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15413                     { " EXPORTS", LL_EXPORTS },
15414                     { " DELAY_LOAD", LL_DELAY_LOAD },
15415                     { " DELTA", LL_DELTA }
15416                   };
15417                   int flags = liblist.l_flags;
15418                   size_t fcnt;
15419
15420                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15421                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15422                       {
15423                         fputs (l_flags_vals[fcnt].name, stdout);
15424                         flags ^= l_flags_vals[fcnt].bit;
15425                       }
15426                   if (flags != 0)
15427                     printf (" %#x", (unsigned int) flags);
15428
15429                   puts ("");
15430                 }
15431             }
15432
15433           free (elib);
15434         }
15435       else
15436         res = FALSE;
15437     }
15438
15439   if (options_offset != 0)
15440     {
15441       Elf_External_Options * eopt;
15442       Elf_Internal_Options * iopt;
15443       Elf_Internal_Options * option;
15444       size_t offset;
15445       int cnt;
15446       sect = section_headers;
15447
15448       /* Find the section header so that we get the size.  */
15449       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15450       /* PR 17533 file: 012-277276-0.004.  */
15451       if (sect == NULL)
15452         {
15453           error (_("No MIPS_OPTIONS header found\n"));
15454           return FALSE;
15455         }
15456
15457       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15458                                                 sect->sh_size, _("options"));
15459       if (eopt)
15460         {
15461           iopt = (Elf_Internal_Options *)
15462               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15463           if (iopt == NULL)
15464             {
15465               error (_("Out of memory allocating space for MIPS options\n"));
15466               return FALSE;
15467             }
15468
15469           offset = cnt = 0;
15470           option = iopt;
15471
15472           while (offset <= sect->sh_size - sizeof (* eopt))
15473             {
15474               Elf_External_Options * eoption;
15475
15476               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15477
15478               option->kind = BYTE_GET (eoption->kind);
15479               option->size = BYTE_GET (eoption->size);
15480               option->section = BYTE_GET (eoption->section);
15481               option->info = BYTE_GET (eoption->info);
15482
15483               /* PR 17531: file: ffa0fa3b.  */
15484               if (option->size < sizeof (* eopt)
15485                   || offset + option->size > sect->sh_size)
15486                 {
15487                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15488                   return FALSE;
15489                 }
15490               offset += option->size;
15491
15492               ++option;
15493               ++cnt;
15494             }
15495
15496           printf (_("\nSection '%s' contains %d entries:\n"),
15497                   printable_section_name (sect), cnt);
15498
15499           option = iopt;
15500           offset = 0;
15501
15502           while (cnt-- > 0)
15503             {
15504               size_t len;
15505
15506               switch (option->kind)
15507                 {
15508                 case ODK_NULL:
15509                   /* This shouldn't happen.  */
15510                   printf (" NULL       %d %lx", option->section, option->info);
15511                   break;
15512                 case ODK_REGINFO:
15513                   printf (" REGINFO    ");
15514                   if (elf_header.e_machine == EM_MIPS)
15515                     {
15516                       /* 32bit form.  */
15517                       Elf32_External_RegInfo * ereg;
15518                       Elf32_RegInfo reginfo;
15519
15520                       ereg = (Elf32_External_RegInfo *) (option + 1);
15521                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15522                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15523                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15524                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15525                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15526                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15527
15528                       printf ("GPR %08lx  GP 0x%lx\n",
15529                               reginfo.ri_gprmask,
15530                               (unsigned long) reginfo.ri_gp_value);
15531                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15532                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15533                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15534                     }
15535                   else
15536                     {
15537                       /* 64 bit form.  */
15538                       Elf64_External_RegInfo * ereg;
15539                       Elf64_Internal_RegInfo reginfo;
15540
15541                       ereg = (Elf64_External_RegInfo *) (option + 1);
15542                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15543                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15544                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15545                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15546                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15547                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15548
15549                       printf ("GPR %08lx  GP 0x",
15550                               reginfo.ri_gprmask);
15551                       printf_vma (reginfo.ri_gp_value);
15552                       printf ("\n");
15553
15554                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15555                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15556                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15557                     }
15558                   ++option;
15559                   continue;
15560                 case ODK_EXCEPTIONS:
15561                   fputs (" EXCEPTIONS fpe_min(", stdout);
15562                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15563                   fputs (") fpe_max(", stdout);
15564                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15565                   fputs (")", stdout);
15566
15567                   if (option->info & OEX_PAGE0)
15568                     fputs (" PAGE0", stdout);
15569                   if (option->info & OEX_SMM)
15570                     fputs (" SMM", stdout);
15571                   if (option->info & OEX_FPDBUG)
15572                     fputs (" FPDBUG", stdout);
15573                   if (option->info & OEX_DISMISS)
15574                     fputs (" DISMISS", stdout);
15575                   break;
15576                 case ODK_PAD:
15577                   fputs (" PAD       ", stdout);
15578                   if (option->info & OPAD_PREFIX)
15579                     fputs (" PREFIX", stdout);
15580                   if (option->info & OPAD_POSTFIX)
15581                     fputs (" POSTFIX", stdout);
15582                   if (option->info & OPAD_SYMBOL)
15583                     fputs (" SYMBOL", stdout);
15584                   break;
15585                 case ODK_HWPATCH:
15586                   fputs (" HWPATCH   ", stdout);
15587                   if (option->info & OHW_R4KEOP)
15588                     fputs (" R4KEOP", stdout);
15589                   if (option->info & OHW_R8KPFETCH)
15590                     fputs (" R8KPFETCH", stdout);
15591                   if (option->info & OHW_R5KEOP)
15592                     fputs (" R5KEOP", stdout);
15593                   if (option->info & OHW_R5KCVTL)
15594                     fputs (" R5KCVTL", stdout);
15595                   break;
15596                 case ODK_FILL:
15597                   fputs (" FILL       ", stdout);
15598                   /* XXX Print content of info word?  */
15599                   break;
15600                 case ODK_TAGS:
15601                   fputs (" TAGS       ", stdout);
15602                   /* XXX Print content of info word?  */
15603                   break;
15604                 case ODK_HWAND:
15605                   fputs (" HWAND     ", stdout);
15606                   if (option->info & OHWA0_R4KEOP_CHECKED)
15607                     fputs (" R4KEOP_CHECKED", stdout);
15608                   if (option->info & OHWA0_R4KEOP_CLEAN)
15609                     fputs (" R4KEOP_CLEAN", stdout);
15610                   break;
15611                 case ODK_HWOR:
15612                   fputs (" HWOR      ", stdout);
15613                   if (option->info & OHWA0_R4KEOP_CHECKED)
15614                     fputs (" R4KEOP_CHECKED", stdout);
15615                   if (option->info & OHWA0_R4KEOP_CLEAN)
15616                     fputs (" R4KEOP_CLEAN", stdout);
15617                   break;
15618                 case ODK_GP_GROUP:
15619                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15620                           option->info & OGP_GROUP,
15621                           (option->info & OGP_SELF) >> 16);
15622                   break;
15623                 case ODK_IDENT:
15624                   printf (" IDENT     %#06lx  self-contained %#06lx",
15625                           option->info & OGP_GROUP,
15626                           (option->info & OGP_SELF) >> 16);
15627                   break;
15628                 default:
15629                   /* This shouldn't happen.  */
15630                   printf (" %3d ???     %d %lx",
15631                           option->kind, option->section, option->info);
15632                   break;
15633                 }
15634
15635               len = sizeof (* eopt);
15636               while (len < option->size)
15637                 {
15638                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15639
15640                   if (ISPRINT (datum))
15641                     printf ("%c", datum);
15642                   else
15643                     printf ("\\%03o", datum);
15644                   len ++;
15645                 }
15646               fputs ("\n", stdout);
15647
15648               offset += option->size;
15649               ++option;
15650             }
15651
15652           free (eopt);
15653         }
15654       else
15655         res = FALSE;
15656     }
15657
15658   if (conflicts_offset != 0 && conflictsno != 0)
15659     {
15660       Elf32_Conflict * iconf;
15661       size_t cnt;
15662
15663       if (dynamic_symbols == NULL)
15664         {
15665           error (_("conflict list found without a dynamic symbol table\n"));
15666           return FALSE;
15667         }
15668
15669       /* PR 21345 - print a slightly more helpful error message
15670          if we are sure that the cmalloc will fail.  */
15671       if (conflictsno * sizeof (* iconf) > current_file_size)
15672         {
15673           error (_("Overlarge number of conflicts detected: %lx\n"),
15674                  (long) conflictsno);
15675           return FALSE;
15676         }
15677
15678       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15679       if (iconf == NULL)
15680         {
15681           error (_("Out of memory allocating space for dynamic conflicts\n"));
15682           return FALSE;
15683         }
15684
15685       if (is_32bit_elf)
15686         {
15687           Elf32_External_Conflict * econf32;
15688
15689           econf32 = (Elf32_External_Conflict *)
15690               get_data (NULL, file, conflicts_offset, conflictsno,
15691                         sizeof (* econf32), _("conflict"));
15692           if (!econf32)
15693             return FALSE;
15694
15695           for (cnt = 0; cnt < conflictsno; ++cnt)
15696             iconf[cnt] = BYTE_GET (econf32[cnt]);
15697
15698           free (econf32);
15699         }
15700       else
15701         {
15702           Elf64_External_Conflict * econf64;
15703
15704           econf64 = (Elf64_External_Conflict *)
15705               get_data (NULL, file, conflicts_offset, conflictsno,
15706                         sizeof (* econf64), _("conflict"));
15707           if (!econf64)
15708             return FALSE;
15709
15710           for (cnt = 0; cnt < conflictsno; ++cnt)
15711             iconf[cnt] = BYTE_GET (econf64[cnt]);
15712
15713           free (econf64);
15714         }
15715
15716       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15717               (unsigned long) conflictsno);
15718       puts (_("  Num:    Index       Value  Name"));
15719
15720       for (cnt = 0; cnt < conflictsno; ++cnt)
15721         {
15722           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15723
15724           if (iconf[cnt] >= num_dynamic_syms)
15725             printf (_("<corrupt symbol index>"));
15726           else
15727             {
15728               Elf_Internal_Sym * psym;
15729
15730               psym = & dynamic_symbols[iconf[cnt]];
15731               print_vma (psym->st_value, FULL_HEX);
15732               putchar (' ');
15733               if (VALID_DYNAMIC_NAME (psym->st_name))
15734                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15735               else
15736                 printf (_("<corrupt: %14ld>"), psym->st_name);
15737             }
15738           putchar ('\n');
15739         }
15740
15741       free (iconf);
15742     }
15743
15744   if (pltgot != 0 && local_gotno != 0)
15745     {
15746       bfd_vma ent, local_end, global_end;
15747       size_t i, offset;
15748       unsigned char * data;
15749       unsigned char * data_end;
15750       int addr_size;
15751
15752       ent = pltgot;
15753       addr_size = (is_32bit_elf ? 4 : 8);
15754       local_end = pltgot + local_gotno * addr_size;
15755
15756       /* PR binutils/17533 file: 012-111227-0.004  */
15757       if (symtabno < gotsym)
15758         {
15759           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15760                  (unsigned long) gotsym, (unsigned long) symtabno);
15761           return FALSE;
15762         }
15763
15764       global_end = local_end + (symtabno - gotsym) * addr_size;
15765       /* PR 17531: file: 54c91a34.  */
15766       if (global_end < local_end)
15767         {
15768           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15769           return FALSE;
15770         }
15771
15772       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15773       data = (unsigned char *) get_data (NULL, file, offset,
15774                                          global_end - pltgot, 1,
15775                                          _("Global Offset Table data"));
15776       /* PR 12855: Null data is handled gracefully throughout.  */
15777       data_end = data + (global_end - pltgot);
15778
15779       printf (_("\nPrimary GOT:\n"));
15780       printf (_(" Canonical gp value: "));
15781       print_vma (pltgot + 0x7ff0, LONG_HEX);
15782       printf ("\n\n");
15783
15784       printf (_(" Reserved entries:\n"));
15785       printf (_("  %*s %10s %*s Purpose\n"),
15786               addr_size * 2, _("Address"), _("Access"),
15787               addr_size * 2, _("Initial"));
15788       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15789       printf (_(" Lazy resolver\n"));
15790       if (ent == (bfd_vma) -1)
15791         goto got_print_fail;
15792
15793       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15794          This entry will be used by some runtime loaders, to store the
15795          module pointer.  Otherwise this is an ordinary local entry.
15796          PR 21344: Check for the entry being fully available before
15797          fetching it.  */
15798       if (data
15799           && data + ent - pltgot + addr_size <= data_end
15800           && (byte_get (data + ent - pltgot, addr_size)
15801               >> (addr_size * 8 - 1)) != 0)
15802         {
15803           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15804           printf (_(" Module pointer (GNU extension)\n"));
15805           if (ent == (bfd_vma) -1)
15806             goto got_print_fail;
15807         }
15808       printf ("\n");
15809
15810       if (ent < local_end)
15811         {
15812           printf (_(" Local entries:\n"));
15813           printf ("  %*s %10s %*s\n",
15814                   addr_size * 2, _("Address"), _("Access"),
15815                   addr_size * 2, _("Initial"));
15816           while (ent < local_end)
15817             {
15818               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15819               printf ("\n");
15820               if (ent == (bfd_vma) -1)
15821                 goto got_print_fail;
15822             }
15823           printf ("\n");
15824         }
15825
15826       if (gotsym < symtabno)
15827         {
15828           int sym_width;
15829
15830           printf (_(" Global entries:\n"));
15831           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15832                   addr_size * 2, _("Address"),
15833                   _("Access"),
15834                   addr_size * 2, _("Initial"),
15835                   addr_size * 2, _("Sym.Val."),
15836                   _("Type"),
15837                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15838                   _("Ndx"), _("Name"));
15839
15840           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15841
15842           for (i = gotsym; i < symtabno; i++)
15843             {
15844               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15845               printf (" ");
15846
15847               if (dynamic_symbols == NULL)
15848                 printf (_("<no dynamic symbols>"));
15849               else if (i < num_dynamic_syms)
15850                 {
15851                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15852
15853                   print_vma (psym->st_value, LONG_HEX);
15854                   printf (" %-7s %3s ",
15855                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15856                           get_symbol_index_type (psym->st_shndx));
15857
15858                   if (VALID_DYNAMIC_NAME (psym->st_name))
15859                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15860                   else
15861                     printf (_("<corrupt: %14ld>"), psym->st_name);
15862                 }
15863               else
15864                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15865                         (unsigned long) i);
15866
15867               printf ("\n");
15868               if (ent == (bfd_vma) -1)
15869                 break;
15870             }
15871           printf ("\n");
15872         }
15873
15874     got_print_fail:
15875       if (data)
15876         free (data);
15877     }
15878
15879   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15880     {
15881       bfd_vma ent, end;
15882       size_t offset, rel_offset;
15883       unsigned long count, i;
15884       unsigned char * data;
15885       int addr_size, sym_width;
15886       Elf_Internal_Rela * rels;
15887
15888       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15889       if (pltrel == DT_RELA)
15890         {
15891           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15892             return FALSE;
15893         }
15894       else
15895         {
15896           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15897             return FALSE;
15898         }
15899
15900       ent = mips_pltgot;
15901       addr_size = (is_32bit_elf ? 4 : 8);
15902       end = mips_pltgot + (2 + count) * addr_size;
15903
15904       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15905       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15906                                          1, _("Procedure Linkage Table data"));
15907       if (data == NULL)
15908         return FALSE;
15909
15910       printf ("\nPLT GOT:\n\n");
15911       printf (_(" Reserved entries:\n"));
15912       printf (_("  %*s %*s Purpose\n"),
15913               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15914       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15915       printf (_(" PLT lazy resolver\n"));
15916       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15917       printf (_(" Module pointer\n"));
15918       printf ("\n");
15919
15920       printf (_(" Entries:\n"));
15921       printf ("  %*s %*s %*s %-7s %3s %s\n",
15922               addr_size * 2, _("Address"),
15923               addr_size * 2, _("Initial"),
15924               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15925       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15926       for (i = 0; i < count; i++)
15927         {
15928           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15929
15930           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15931           printf (" ");
15932
15933           if (idx >= num_dynamic_syms)
15934             printf (_("<corrupt symbol index: %lu>"), idx);
15935           else
15936             {
15937               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15938
15939               print_vma (psym->st_value, LONG_HEX);
15940               printf (" %-7s %3s ",
15941                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15942                       get_symbol_index_type (psym->st_shndx));
15943               if (VALID_DYNAMIC_NAME (psym->st_name))
15944                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15945               else
15946                 printf (_("<corrupt: %14ld>"), psym->st_name);
15947             }
15948           printf ("\n");
15949         }
15950       printf ("\n");
15951
15952       if (data)
15953         free (data);
15954       free (rels);
15955     }
15956
15957   return res;
15958 }
15959
15960 static bfd_boolean
15961 process_nds32_specific (FILE * file)
15962 {
15963   Elf_Internal_Shdr *sect = NULL;
15964
15965   sect = find_section (".nds32_e_flags");
15966   if (sect != NULL)
15967     {
15968       unsigned int *flag;
15969
15970       printf ("\nNDS32 elf flags section:\n");
15971       flag = get_data (NULL, file, sect->sh_offset, 1,
15972                        sect->sh_size, _("NDS32 elf flags section"));
15973
15974       if (! flag)
15975         return FALSE;
15976
15977       switch ((*flag) & 0x3)
15978         {
15979         case 0:
15980           printf ("(VEC_SIZE):\tNo entry.\n");
15981           break;
15982         case 1:
15983           printf ("(VEC_SIZE):\t4 bytes\n");
15984           break;
15985         case 2:
15986           printf ("(VEC_SIZE):\t16 bytes\n");
15987           break;
15988         case 3:
15989           printf ("(VEC_SIZE):\treserved\n");
15990           break;
15991         }
15992     }
15993
15994   return TRUE;
15995 }
15996
15997 static bfd_boolean
15998 process_gnu_liblist (FILE * file)
15999 {
16000   Elf_Internal_Shdr * section;
16001   Elf_Internal_Shdr * string_sec;
16002   Elf32_External_Lib * elib;
16003   char * strtab;
16004   size_t strtab_size;
16005   size_t cnt;
16006   unsigned i;
16007   bfd_boolean res = TRUE;
16008
16009   if (! do_arch)
16010     return TRUE;
16011
16012   for (i = 0, section = section_headers;
16013        i < elf_header.e_shnum;
16014        i++, section++)
16015     {
16016       switch (section->sh_type)
16017         {
16018         case SHT_GNU_LIBLIST:
16019           if (section->sh_link >= elf_header.e_shnum)
16020             break;
16021
16022           elib = (Elf32_External_Lib *)
16023               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16024                         _("liblist section data"));
16025
16026           if (elib == NULL)
16027             {
16028               res = FALSE;
16029               break;
16030             }
16031
16032           string_sec = section_headers + section->sh_link;
16033           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16034                                       string_sec->sh_size,
16035                                       _("liblist string table"));
16036           if (strtab == NULL
16037               || section->sh_entsize != sizeof (Elf32_External_Lib))
16038             {
16039               free (elib);
16040               free (strtab);
16041               res = FALSE;
16042               break;
16043             }
16044           strtab_size = string_sec->sh_size;
16045
16046           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16047                   printable_section_name (section),
16048                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16049
16050           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16051
16052           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16053                ++cnt)
16054             {
16055               Elf32_Lib liblist;
16056               time_t atime;
16057               char timebuf[128];
16058               struct tm * tmp;
16059
16060               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16061               atime = BYTE_GET (elib[cnt].l_time_stamp);
16062               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16063               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16064               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16065
16066               tmp = gmtime (&atime);
16067               snprintf (timebuf, sizeof (timebuf),
16068                         "%04u-%02u-%02uT%02u:%02u:%02u",
16069                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16070                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16071
16072               printf ("%3lu: ", (unsigned long) cnt);
16073               if (do_wide)
16074                 printf ("%-20s", liblist.l_name < strtab_size
16075                         ? strtab + liblist.l_name : _("<corrupt>"));
16076               else
16077                 printf ("%-20.20s", liblist.l_name < strtab_size
16078                         ? strtab + liblist.l_name : _("<corrupt>"));
16079               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16080                       liblist.l_version, liblist.l_flags);
16081             }
16082
16083           free (elib);
16084           free (strtab);
16085         }
16086     }
16087
16088   return res;
16089 }
16090
16091 static const char *
16092 get_note_type (unsigned e_type)
16093 {
16094   static char buff[64];
16095
16096   if (elf_header.e_type == ET_CORE)
16097     switch (e_type)
16098       {
16099       case NT_AUXV:
16100         return _("NT_AUXV (auxiliary vector)");
16101       case NT_PRSTATUS:
16102         return _("NT_PRSTATUS (prstatus structure)");
16103       case NT_FPREGSET:
16104         return _("NT_FPREGSET (floating point registers)");
16105       case NT_PRPSINFO:
16106         return _("NT_PRPSINFO (prpsinfo structure)");
16107       case NT_TASKSTRUCT:
16108         return _("NT_TASKSTRUCT (task structure)");
16109       case NT_PRXFPREG:
16110         return _("NT_PRXFPREG (user_xfpregs structure)");
16111       case NT_PPC_VMX:
16112         return _("NT_PPC_VMX (ppc Altivec registers)");
16113       case NT_PPC_VSX:
16114         return _("NT_PPC_VSX (ppc VSX registers)");
16115       case NT_386_TLS:
16116         return _("NT_386_TLS (x86 TLS information)");
16117       case NT_386_IOPERM:
16118         return _("NT_386_IOPERM (x86 I/O permissions)");
16119       case NT_X86_XSTATE:
16120         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16121       case NT_S390_HIGH_GPRS:
16122         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16123       case NT_S390_TIMER:
16124         return _("NT_S390_TIMER (s390 timer register)");
16125       case NT_S390_TODCMP:
16126         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16127       case NT_S390_TODPREG:
16128         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16129       case NT_S390_CTRS:
16130         return _("NT_S390_CTRS (s390 control registers)");
16131       case NT_S390_PREFIX:
16132         return _("NT_S390_PREFIX (s390 prefix register)");
16133       case NT_S390_LAST_BREAK:
16134         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16135       case NT_S390_SYSTEM_CALL:
16136         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16137       case NT_S390_TDB:
16138         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16139       case NT_S390_VXRS_LOW:
16140         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16141       case NT_S390_VXRS_HIGH:
16142         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16143       case NT_ARM_VFP:
16144         return _("NT_ARM_VFP (arm VFP registers)");
16145       case NT_ARM_TLS:
16146         return _("NT_ARM_TLS (AArch TLS registers)");
16147       case NT_ARM_HW_BREAK:
16148         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16149       case NT_ARM_HW_WATCH:
16150         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16151       case NT_PSTATUS:
16152         return _("NT_PSTATUS (pstatus structure)");
16153       case NT_FPREGS:
16154         return _("NT_FPREGS (floating point registers)");
16155       case NT_PSINFO:
16156         return _("NT_PSINFO (psinfo structure)");
16157       case NT_LWPSTATUS:
16158         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16159       case NT_LWPSINFO:
16160         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16161       case NT_WIN32PSTATUS:
16162         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16163       case NT_SIGINFO:
16164         return _("NT_SIGINFO (siginfo_t data)");
16165       case NT_FILE:
16166         return _("NT_FILE (mapped files)");
16167       default:
16168         break;
16169       }
16170   else
16171     switch (e_type)
16172       {
16173       case NT_VERSION:
16174         return _("NT_VERSION (version)");
16175       case NT_ARCH:
16176         return _("NT_ARCH (architecture)");
16177       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16178         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16179       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16180         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16181       default:
16182         break;
16183       }
16184
16185   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16186   return buff;
16187 }
16188
16189 static bfd_boolean
16190 print_core_note (Elf_Internal_Note *pnote)
16191 {
16192   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16193   bfd_vma count, page_size;
16194   unsigned char *descdata, *filenames, *descend;
16195
16196   if (pnote->type != NT_FILE)
16197     return TRUE;
16198
16199 #ifndef BFD64
16200   if (!is_32bit_elf)
16201     {
16202       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16203       /* Still "successful".  */
16204       return TRUE;
16205     }
16206 #endif
16207
16208   if (pnote->descsz < 2 * addr_size)
16209     {
16210       error (_("    Malformed note - too short for header\n"));
16211       return FALSE;
16212     }
16213
16214   descdata = (unsigned char *) pnote->descdata;
16215   descend = descdata + pnote->descsz;
16216
16217   if (descdata[pnote->descsz - 1] != '\0')
16218     {
16219       error (_("    Malformed note - does not end with \\0\n"));
16220       return FALSE;
16221     }
16222
16223   count = byte_get (descdata, addr_size);
16224   descdata += addr_size;
16225
16226   page_size = byte_get (descdata, addr_size);
16227   descdata += addr_size;
16228
16229   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16230     {
16231       error (_("    Malformed note - too short for supplied file count\n"));
16232       return FALSE;
16233     }
16234
16235   printf (_("    Page size: "));
16236   print_vma (page_size, DEC);
16237   printf ("\n");
16238
16239   printf (_("    %*s%*s%*s\n"),
16240           (int) (2 + 2 * addr_size), _("Start"),
16241           (int) (4 + 2 * addr_size), _("End"),
16242           (int) (4 + 2 * addr_size), _("Page Offset"));
16243   filenames = descdata + count * 3 * addr_size;
16244   while (count-- > 0)
16245     {
16246       bfd_vma start, end, file_ofs;
16247
16248       if (filenames == descend)
16249         {
16250           error (_("    Malformed note - filenames end too early\n"));
16251           return FALSE;
16252         }
16253
16254       start = byte_get (descdata, addr_size);
16255       descdata += addr_size;
16256       end = byte_get (descdata, addr_size);
16257       descdata += addr_size;
16258       file_ofs = byte_get (descdata, addr_size);
16259       descdata += addr_size;
16260
16261       printf ("    ");
16262       print_vma (start, FULL_HEX);
16263       printf ("  ");
16264       print_vma (end, FULL_HEX);
16265       printf ("  ");
16266       print_vma (file_ofs, FULL_HEX);
16267       printf ("\n        %s\n", filenames);
16268
16269       filenames += 1 + strlen ((char *) filenames);
16270     }
16271
16272   return TRUE;
16273 }
16274
16275 static const char *
16276 get_gnu_elf_note_type (unsigned e_type)
16277 {
16278   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16279   switch (e_type)
16280     {
16281     case NT_GNU_ABI_TAG:
16282       return _("NT_GNU_ABI_TAG (ABI version tag)");
16283     case NT_GNU_HWCAP:
16284       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16285     case NT_GNU_BUILD_ID:
16286       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16287     case NT_GNU_GOLD_VERSION:
16288       return _("NT_GNU_GOLD_VERSION (gold version)");
16289     case NT_GNU_PROPERTY_TYPE_0:
16290       return _("NT_GNU_PROPERTY_TYPE_0");
16291     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16292       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16293     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16294       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16295     default:
16296       {
16297         static char buff[64];
16298
16299         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16300         return buff;
16301       }
16302     }
16303 }
16304
16305 static void
16306 decode_x86_isa (unsigned int bitmask)
16307 {
16308   while (bitmask)
16309     {
16310       unsigned int bit = bitmask & (- bitmask);
16311
16312       bitmask &= ~ bit;
16313       switch (bit)
16314         {
16315         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16316         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16317         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16318         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16319         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16320         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16321         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16322         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16323         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16324         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16325         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16326         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16327         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16328         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16329         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16330         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16331         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16332         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16333         default: printf (_("<unknown: %x>"), bit); break;
16334         }
16335       if (bitmask)
16336         printf (", ");
16337     }
16338 }
16339
16340 static void
16341 print_gnu_property_note (Elf_Internal_Note * pnote)
16342 {
16343   unsigned char * ptr = (unsigned char *) pnote->descdata;
16344   unsigned char * ptr_end = ptr + pnote->descsz;
16345   unsigned int    size = is_32bit_elf ? 4 : 8;
16346
16347   printf (_("      Properties: "));
16348
16349   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16350     {
16351       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16352       return;
16353     }
16354
16355   while (1)
16356     {
16357       unsigned int j;
16358       unsigned int type = byte_get (ptr, 4);
16359       unsigned int datasz = byte_get (ptr + 4, 4);
16360
16361       ptr += 8;
16362
16363       if ((ptr + datasz) > ptr_end)
16364         {
16365           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16366                   type, datasz);
16367           break;
16368         }
16369
16370       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16371         {
16372           if (elf_header.e_machine == EM_X86_64
16373               || elf_header.e_machine == EM_IAMCU
16374               || elf_header.e_machine == EM_386)
16375             {
16376               switch (type)
16377                 {
16378                 case GNU_PROPERTY_X86_ISA_1_USED:
16379                   printf ("x86 ISA used: ");
16380                   if (datasz != 4)
16381                     printf (_("<corrupt length: %#x> "), datasz);
16382                   else
16383                     decode_x86_isa (byte_get (ptr, 4));
16384                   goto next;
16385
16386                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16387                   printf ("x86 ISA needed: ");
16388                   if (datasz != 4)
16389                     printf (_("<corrupt length: %#x> "), datasz);
16390                   else
16391                     decode_x86_isa (byte_get (ptr, 4));
16392                   goto next;
16393
16394                 default:
16395                   break;
16396                 }
16397             }
16398         }
16399       else
16400         {
16401           switch (type)
16402             {
16403             case GNU_PROPERTY_STACK_SIZE:
16404               printf (_("stack size: "));
16405               if (datasz != size)
16406                 printf (_("<corrupt length: %#x> "), datasz);
16407               else
16408                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16409               goto next;
16410
16411             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16412               printf ("no copy on protected ");
16413               if (datasz)
16414                 printf (_("<corrupt length: %#x> "), datasz);
16415               goto next;
16416
16417             default:
16418               break;
16419             }
16420         }
16421
16422       if (type < GNU_PROPERTY_LOPROC)
16423         printf (_("<unknown type %#x data: "), type);
16424       else if (type < GNU_PROPERTY_LOUSER)
16425         printf (_("<procesor-specific type %#x data: "), type);
16426       else
16427         printf (_("<application-specific type %#x data: "), type);
16428       for (j = 0; j < datasz; ++j)
16429         printf ("%02x ", ptr[j] & 0xff);
16430       printf (">");
16431
16432 next:
16433       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16434       if (ptr == ptr_end)
16435         break;
16436       else
16437         {
16438           if (do_wide)
16439             printf (", ");
16440           else
16441             printf ("\n\t");
16442         }
16443
16444       if (ptr > (ptr_end - 8))
16445         {
16446           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16447           break;
16448         }
16449     }
16450
16451   printf ("\n");
16452 }
16453
16454 static bfd_boolean
16455 print_gnu_note (Elf_Internal_Note *pnote)
16456 {
16457   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16458   switch (pnote->type)
16459     {
16460     case NT_GNU_BUILD_ID:
16461       {
16462         unsigned long i;
16463
16464         printf (_("    Build ID: "));
16465         for (i = 0; i < pnote->descsz; ++i)
16466           printf ("%02x", pnote->descdata[i] & 0xff);
16467         printf ("\n");
16468       }
16469       break;
16470
16471     case NT_GNU_ABI_TAG:
16472       {
16473         unsigned long os, major, minor, subminor;
16474         const char *osname;
16475
16476         /* PR 17531: file: 030-599401-0.004.  */
16477         if (pnote->descsz < 16)
16478           {
16479             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16480             break;
16481           }
16482
16483         os = byte_get ((unsigned char *) pnote->descdata, 4);
16484         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16485         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16486         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16487
16488         switch (os)
16489           {
16490           case GNU_ABI_TAG_LINUX:
16491             osname = "Linux";
16492             break;
16493           case GNU_ABI_TAG_HURD:
16494             osname = "Hurd";
16495             break;
16496           case GNU_ABI_TAG_SOLARIS:
16497             osname = "Solaris";
16498             break;
16499           case GNU_ABI_TAG_FREEBSD:
16500             osname = "FreeBSD";
16501             break;
16502           case GNU_ABI_TAG_NETBSD:
16503             osname = "NetBSD";
16504             break;
16505           case GNU_ABI_TAG_SYLLABLE:
16506             osname = "Syllable";
16507             break;
16508           case GNU_ABI_TAG_NACL:
16509             osname = "NaCl";
16510             break;
16511           default:
16512             osname = "Unknown";
16513             break;
16514           }
16515
16516         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16517                 major, minor, subminor);
16518       }
16519       break;
16520
16521     case NT_GNU_GOLD_VERSION:
16522       {
16523         unsigned long i;
16524
16525         printf (_("    Version: "));
16526         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16527           printf ("%c", pnote->descdata[i]);
16528         printf ("\n");
16529       }
16530       break;
16531
16532     case NT_GNU_HWCAP:
16533       {
16534         unsigned long num_entries, mask;
16535
16536         /* Hardware capabilities information.  Word 0 is the number of entries.
16537            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16538            is a series of entries, where each entry is a single byte followed
16539            by a nul terminated string.  The byte gives the bit number to test
16540            if enabled in the bitmask.  */
16541         printf (_("      Hardware Capabilities: "));
16542         if (pnote->descsz < 8)
16543           {
16544             error (_("<corrupt GNU_HWCAP>\n"));
16545             return FALSE;
16546           }
16547         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16548         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16549         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16550         /* FIXME: Add code to display the entries... */
16551       }
16552       break;
16553
16554     case NT_GNU_PROPERTY_TYPE_0:
16555       print_gnu_property_note (pnote);
16556       break;
16557
16558     default:
16559       /* Handle unrecognised types.  An error message should have already been
16560          created by get_gnu_elf_note_type(), so all that we need to do is to
16561          display the data.  */
16562       {
16563         unsigned long i;
16564
16565         printf (_("    Description data: "));
16566         for (i = 0; i < pnote->descsz; ++i)
16567           printf ("%02x ", pnote->descdata[i] & 0xff);
16568         printf ("\n");
16569       }
16570       break;
16571     }
16572
16573   return TRUE;
16574 }
16575
16576 static const char *
16577 get_v850_elf_note_type (enum v850_notes n_type)
16578 {
16579   static char buff[64];
16580
16581   switch (n_type)
16582     {
16583     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16584     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16585     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16586     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16587     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16588     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16589     default:
16590       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16591       return buff;
16592     }
16593 }
16594
16595 static bfd_boolean
16596 print_v850_note (Elf_Internal_Note * pnote)
16597 {
16598   unsigned int val;
16599
16600   if (pnote->descsz != 4)
16601     return FALSE;
16602
16603   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16604
16605   if (val == 0)
16606     {
16607       printf (_("not set\n"));
16608       return TRUE;
16609     }
16610
16611   switch (pnote->type)
16612     {
16613     case V850_NOTE_ALIGNMENT:
16614       switch (val)
16615         {
16616         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16617         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16618         }
16619       break;
16620
16621     case V850_NOTE_DATA_SIZE:
16622       switch (val)
16623         {
16624         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16625         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16626         }
16627       break;
16628
16629     case V850_NOTE_FPU_INFO:
16630       switch (val)
16631         {
16632         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16633         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16634         }
16635       break;
16636
16637     case V850_NOTE_MMU_INFO:
16638     case V850_NOTE_CACHE_INFO:
16639     case V850_NOTE_SIMD_INFO:
16640       if (val == EF_RH850_SIMD)
16641         {
16642           printf (_("yes\n"));
16643           return TRUE;
16644         }
16645       break;
16646
16647     default:
16648       /* An 'unknown note type' message will already have been displayed.  */
16649       break;
16650     }
16651
16652   printf (_("unknown value: %x\n"), val);
16653   return FALSE;
16654 }
16655
16656 static bfd_boolean
16657 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16658 {
16659   unsigned int version;
16660
16661   switch (pnote->type)
16662     {
16663     case NT_NETBSD_IDENT:
16664       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16665       if ((version / 10000) % 100)
16666         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16667                 version, version / 100000000, (version / 1000000) % 100,
16668                 (version / 10000) % 100 > 26 ? "Z" : "",
16669                 'A' + (version / 10000) % 26);
16670       else
16671         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16672                 version, version / 100000000, (version / 1000000) % 100,
16673                 (version / 100) % 100);
16674       return TRUE;
16675
16676     case NT_NETBSD_MARCH:
16677       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16678               pnote->descdata);
16679       return TRUE;
16680
16681     default:
16682       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16683               pnote->type);
16684       return FALSE;
16685     }
16686 }
16687
16688 static const char *
16689 get_freebsd_elfcore_note_type (unsigned e_type)
16690 {
16691   switch (e_type)
16692     {
16693     case NT_FREEBSD_THRMISC:
16694       return _("NT_THRMISC (thrmisc structure)");
16695     case NT_FREEBSD_PROCSTAT_PROC:
16696       return _("NT_PROCSTAT_PROC (proc data)");
16697     case NT_FREEBSD_PROCSTAT_FILES:
16698       return _("NT_PROCSTAT_FILES (files data)");
16699     case NT_FREEBSD_PROCSTAT_VMMAP:
16700       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16701     case NT_FREEBSD_PROCSTAT_GROUPS:
16702       return _("NT_PROCSTAT_GROUPS (groups data)");
16703     case NT_FREEBSD_PROCSTAT_UMASK:
16704       return _("NT_PROCSTAT_UMASK (umask data)");
16705     case NT_FREEBSD_PROCSTAT_RLIMIT:
16706       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16707     case NT_FREEBSD_PROCSTAT_OSREL:
16708       return _("NT_PROCSTAT_OSREL (osreldate data)");
16709     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16710       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16711     case NT_FREEBSD_PROCSTAT_AUXV:
16712       return _("NT_PROCSTAT_AUXV (auxv data)");
16713     }
16714   return get_note_type (e_type);
16715 }
16716
16717 static const char *
16718 get_netbsd_elfcore_note_type (unsigned e_type)
16719 {
16720   static char buff[64];
16721
16722   if (e_type == NT_NETBSDCORE_PROCINFO)
16723     {
16724       /* NetBSD core "procinfo" structure.  */
16725       return _("NetBSD procinfo structure");
16726     }
16727
16728   /* As of Jan 2002 there are no other machine-independent notes
16729      defined for NetBSD core files.  If the note type is less
16730      than the start of the machine-dependent note types, we don't
16731      understand it.  */
16732
16733   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16734     {
16735       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16736       return buff;
16737     }
16738
16739   switch (elf_header.e_machine)
16740     {
16741     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16742        and PT_GETFPREGS == mach+2.  */
16743
16744     case EM_OLD_ALPHA:
16745     case EM_ALPHA:
16746     case EM_SPARC:
16747     case EM_SPARC32PLUS:
16748     case EM_SPARCV9:
16749       switch (e_type)
16750         {
16751         case NT_NETBSDCORE_FIRSTMACH + 0:
16752           return _("PT_GETREGS (reg structure)");
16753         case NT_NETBSDCORE_FIRSTMACH + 2:
16754           return _("PT_GETFPREGS (fpreg structure)");
16755         default:
16756           break;
16757         }
16758       break;
16759
16760     /* On all other arch's, PT_GETREGS == mach+1 and
16761        PT_GETFPREGS == mach+3.  */
16762     default:
16763       switch (e_type)
16764         {
16765         case NT_NETBSDCORE_FIRSTMACH + 1:
16766           return _("PT_GETREGS (reg structure)");
16767         case NT_NETBSDCORE_FIRSTMACH + 3:
16768           return _("PT_GETFPREGS (fpreg structure)");
16769         default:
16770           break;
16771         }
16772     }
16773
16774   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16775             e_type - NT_NETBSDCORE_FIRSTMACH);
16776   return buff;
16777 }
16778
16779 static const char *
16780 get_stapsdt_note_type (unsigned e_type)
16781 {
16782   static char buff[64];
16783
16784   switch (e_type)
16785     {
16786     case NT_STAPSDT:
16787       return _("NT_STAPSDT (SystemTap probe descriptors)");
16788
16789     default:
16790       break;
16791     }
16792
16793   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16794   return buff;
16795 }
16796
16797 static bfd_boolean
16798 print_stapsdt_note (Elf_Internal_Note *pnote)
16799 {
16800   int addr_size = is_32bit_elf ? 4 : 8;
16801   char *data = pnote->descdata;
16802   char *data_end = pnote->descdata + pnote->descsz;
16803   bfd_vma pc, base_addr, semaphore;
16804   char *provider, *probe, *arg_fmt;
16805
16806   pc = byte_get ((unsigned char *) data, addr_size);
16807   data += addr_size;
16808   base_addr = byte_get ((unsigned char *) data, addr_size);
16809   data += addr_size;
16810   semaphore = byte_get ((unsigned char *) data, addr_size);
16811   data += addr_size;
16812
16813   provider = data;
16814   data += strlen (data) + 1;
16815   probe = data;
16816   data += strlen (data) + 1;
16817   arg_fmt = data;
16818   data += strlen (data) + 1;
16819
16820   printf (_("    Provider: %s\n"), provider);
16821   printf (_("    Name: %s\n"), probe);
16822   printf (_("    Location: "));
16823   print_vma (pc, FULL_HEX);
16824   printf (_(", Base: "));
16825   print_vma (base_addr, FULL_HEX);
16826   printf (_(", Semaphore: "));
16827   print_vma (semaphore, FULL_HEX);
16828   printf ("\n");
16829   printf (_("    Arguments: %s\n"), arg_fmt);
16830
16831   return data == data_end;
16832 }
16833
16834 static const char *
16835 get_ia64_vms_note_type (unsigned e_type)
16836 {
16837   static char buff[64];
16838
16839   switch (e_type)
16840     {
16841     case NT_VMS_MHD:
16842       return _("NT_VMS_MHD (module header)");
16843     case NT_VMS_LNM:
16844       return _("NT_VMS_LNM (language name)");
16845     case NT_VMS_SRC:
16846       return _("NT_VMS_SRC (source files)");
16847     case NT_VMS_TITLE:
16848       return "NT_VMS_TITLE";
16849     case NT_VMS_EIDC:
16850       return _("NT_VMS_EIDC (consistency check)");
16851     case NT_VMS_FPMODE:
16852       return _("NT_VMS_FPMODE (FP mode)");
16853     case NT_VMS_LINKTIME:
16854       return "NT_VMS_LINKTIME";
16855     case NT_VMS_IMGNAM:
16856       return _("NT_VMS_IMGNAM (image name)");
16857     case NT_VMS_IMGID:
16858       return _("NT_VMS_IMGID (image id)");
16859     case NT_VMS_LINKID:
16860       return _("NT_VMS_LINKID (link id)");
16861     case NT_VMS_IMGBID:
16862       return _("NT_VMS_IMGBID (build id)");
16863     case NT_VMS_GSTNAM:
16864       return _("NT_VMS_GSTNAM (sym table name)");
16865     case NT_VMS_ORIG_DYN:
16866       return "NT_VMS_ORIG_DYN";
16867     case NT_VMS_PATCHTIME:
16868       return "NT_VMS_PATCHTIME";
16869     default:
16870       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16871       return buff;
16872     }
16873 }
16874
16875 static bfd_boolean
16876 print_ia64_vms_note (Elf_Internal_Note * pnote)
16877 {
16878   switch (pnote->type)
16879     {
16880     case NT_VMS_MHD:
16881       if (pnote->descsz > 36)
16882         {
16883           size_t l = strlen (pnote->descdata + 34);
16884           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16885           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16886           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16887           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16888         }
16889       else
16890         printf (_("    Invalid size\n"));
16891       break;
16892     case NT_VMS_LNM:
16893       printf (_("   Language: %s\n"), pnote->descdata);
16894       break;
16895 #ifdef BFD64
16896     case NT_VMS_FPMODE:
16897       printf (_("   Floating Point mode: "));
16898       printf ("0x%016" BFD_VMA_FMT "x\n",
16899               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
16900       break;
16901     case NT_VMS_LINKTIME:
16902       printf (_("   Link time: "));
16903       print_vms_time
16904         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16905       printf ("\n");
16906       break;
16907     case NT_VMS_PATCHTIME:
16908       printf (_("   Patch time: "));
16909       print_vms_time
16910         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16911       printf ("\n");
16912       break;
16913     case NT_VMS_ORIG_DYN:
16914       printf (_("   Major id: %u,  minor id: %u\n"),
16915               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16916               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
16917       printf (_("   Last modified  : "));
16918       print_vms_time
16919         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
16920       printf (_("\n   Link flags  : "));
16921       printf ("0x%016" BFD_VMA_FMT "x\n",
16922               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
16923       printf (_("   Header flags: 0x%08x\n"),
16924               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
16925       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
16926       break;
16927 #endif
16928     case NT_VMS_IMGNAM:
16929       printf (_("    Image name: %s\n"), pnote->descdata);
16930       break;
16931     case NT_VMS_GSTNAM:
16932       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
16933       break;
16934     case NT_VMS_IMGID:
16935       printf (_("    Image id: %s\n"), pnote->descdata);
16936       break;
16937     case NT_VMS_LINKID:
16938       printf (_("    Linker id: %s\n"), pnote->descdata);
16939       break;
16940     default:
16941       return FALSE;
16942     }
16943   return TRUE;
16944 }
16945
16946 /* Print the name of the symbol associated with a build attribute
16947    that is attached to address OFFSET.  */
16948
16949 static bfd_boolean
16950 print_symbol_for_build_attribute (FILE *         file,
16951                                   unsigned long  offset,
16952                                   bfd_boolean    is_open_attr)
16953 {
16954   static FILE *             saved_file = NULL;
16955   static char *             strtab;
16956   static unsigned long      strtablen;
16957   static Elf_Internal_Sym * symtab;
16958   static unsigned long      nsyms;
16959   Elf_Internal_Sym *        saved_sym = NULL;
16960   Elf_Internal_Sym *        sym;
16961
16962   if (section_headers != NULL
16963       && (saved_file == NULL || file != saved_file))
16964     {
16965       Elf_Internal_Shdr * symsec;
16966
16967       /* Load the symbol and string sections.  */
16968       for (symsec = section_headers;
16969            symsec < section_headers + elf_header.e_shnum;
16970            symsec ++)
16971         {
16972           if (symsec->sh_type == SHT_SYMTAB)
16973             {
16974               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
16975
16976               if (symsec->sh_link < elf_header.e_shnum)
16977                 {
16978                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
16979
16980                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
16981                                               1, strtab_sec->sh_size,
16982                                               _("string table"));
16983                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
16984                 }
16985             }
16986         }
16987       saved_file = file;
16988     }
16989
16990   if (symtab == NULL || strtab == NULL)
16991     {
16992       printf ("\n");
16993       return FALSE;
16994     }
16995
16996   /* Find a symbol whose value matches offset.  */
16997   for (sym = symtab; sym < symtab + nsyms; sym ++)
16998     if (sym->st_value == offset)
16999       {
17000         if (sym->st_name >= strtablen)
17001           /* Huh ?  This should not happen.  */
17002           continue;
17003
17004         if (strtab[sym->st_name] == 0)
17005           continue;
17006
17007         if (is_open_attr)
17008           {
17009             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17010                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17011                FUNC symbols entirely.  */
17012             switch (ELF_ST_TYPE (sym->st_info))
17013               {
17014               case STT_FILE:
17015                 saved_sym = sym;
17016                 /* We can stop searching now.  */
17017                 sym = symtab + nsyms;
17018                 continue;
17019
17020               case STT_OBJECT:
17021                 saved_sym = sym;
17022                 continue;
17023
17024               case STT_FUNC:
17025                 /* Ignore function symbols.  */
17026                 continue;
17027
17028               default:
17029                 break;
17030               }
17031
17032             switch (ELF_ST_BIND (sym->st_info))
17033               {
17034               case STB_GLOBAL:
17035                 if (saved_sym == NULL
17036                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17037                   saved_sym = sym;
17038                 break;
17039
17040               case STB_LOCAL:
17041                 if (saved_sym == NULL)
17042                   saved_sym = sym;
17043                 break;
17044
17045               default:
17046                 break;
17047               }
17048           }
17049         else
17050           {
17051             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17052               continue;
17053
17054             saved_sym = sym;
17055             break;
17056           }
17057       }
17058
17059   printf (" (%s: %s)\n",
17060           is_open_attr ? _("file") : _("func"),
17061           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17062   return TRUE;
17063 }
17064
17065 static bfd_boolean
17066 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17067                                        FILE *              file)
17068 {
17069   static unsigned long global_offset = 0;
17070   unsigned long        offset;
17071   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17072   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17073
17074   if (pnote->descsz == 0)
17075     {
17076       if (is_open_attr)
17077         {
17078           printf (_("    Applies from offset %#lx\n"), global_offset);
17079           return TRUE;
17080         }
17081       else
17082         {
17083           printf (_("    Applies to func at %#lx"), global_offset);
17084           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17085         }
17086     }
17087
17088   if (pnote->descsz != desc_size)
17089     {
17090       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17091       printf (_("    <invalid descsz>"));
17092       return FALSE;
17093     }
17094
17095   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17096
17097   if (is_open_attr)
17098     {
17099       printf (_("    Applies from offset %#lx"), offset);
17100       global_offset = offset;
17101     }
17102   else
17103     {
17104       printf (_("    Applies to func at %#lx"), offset);
17105     }
17106
17107   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17108 }
17109
17110 static bfd_boolean
17111 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17112 {
17113   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17114   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17115   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17116   char         name_type;
17117   char         name_attribute;
17118   const char * expected_types;
17119   const char * name = pnote->namedata;
17120   const char * text;
17121   int          left;
17122
17123   if (name == NULL || pnote->namesz < 2)
17124     {
17125       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17126       print_symbol (-20, _("  <corrupt name>"));
17127       return FALSE;
17128     }
17129
17130   switch ((name_type = * name))
17131     {
17132     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17133     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17134     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17135     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17136       printf ("%c", * name);
17137       break;
17138     default:
17139       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17140       print_symbol (-20, _("<unknown name type>"));
17141       return FALSE;
17142     }
17143
17144   left = 19;
17145   ++ name;
17146   text = NULL;
17147
17148   switch ((name_attribute = * name))
17149     {
17150     case GNU_BUILD_ATTRIBUTE_VERSION:
17151       text = _("<version>");
17152       expected_types = string_expected;
17153       ++ name;
17154       break;
17155     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17156       text = _("<stack prot>");
17157       expected_types = "!+*";
17158       ++ name;
17159       break;
17160     case GNU_BUILD_ATTRIBUTE_RELRO:
17161       text = _("<relro>");
17162       expected_types = bool_expected;
17163       ++ name;
17164       break;
17165     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17166       text = _("<stack size>");
17167       expected_types = number_expected;
17168       ++ name;
17169       break;
17170     case GNU_BUILD_ATTRIBUTE_TOOL:
17171       text = _("<tool>");
17172       expected_types = string_expected;
17173       ++ name;
17174       break;
17175     case GNU_BUILD_ATTRIBUTE_ABI:
17176       text = _("<ABI>");
17177       expected_types = "$*";
17178       ++ name;
17179       break;
17180     case GNU_BUILD_ATTRIBUTE_PIC:
17181       text = _("<PIC>");
17182       expected_types = number_expected;
17183       ++ name;
17184       break;
17185     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17186       text = _("<short enum>");
17187       expected_types = bool_expected;
17188       ++ name;
17189       break;
17190     default:
17191       if (ISPRINT (* name))
17192         {
17193           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17194
17195           if (len > left && ! do_wide)
17196             len = left;
17197           printf ("%.*s:", len, name);
17198           left -= len;
17199           name += len;
17200         }
17201       else
17202         {
17203           static char tmpbuf [128];
17204           error (_("unrecognised byte in name field: %d\n"), * name);
17205           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17206           text = tmpbuf;
17207           name ++;
17208         }
17209       expected_types = "*$!+";
17210       break;
17211     }
17212
17213   if (text)
17214     {
17215       printf ("%s", text);
17216       left -= strlen (text);
17217     }
17218
17219   if (strchr (expected_types, name_type) == NULL)
17220     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17221
17222   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17223     {
17224       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17225              (unsigned long) pnote->namesz,
17226              (long) (name - pnote->namedata));
17227       return FALSE;
17228     }
17229
17230   if (left < 1 && ! do_wide)
17231     return TRUE;
17232
17233   switch (name_type)
17234     {
17235     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17236       {
17237         unsigned int        bytes;
17238         unsigned long long  val = 0;
17239         unsigned int        shift = 0;
17240         char *              decoded = NULL;
17241
17242         bytes = pnote->namesz - (name - pnote->namedata);
17243         if (bytes > 0)
17244           /* The -1 is because the name field is always 0 terminated, and we
17245              want to be able to ensure that the shift in the while loop below
17246              will not overflow.  */
17247           -- bytes;
17248
17249         if (bytes > sizeof (val))
17250           {
17251             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17252                      pnote->namesz, name, pnote->namedata);
17253             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17254                    bytes);
17255             bytes = sizeof (val);
17256           }
17257         /* We do not bother to warn if bytes == 0 as this can
17258            happen with some early versions of the gcc plugin.  */
17259
17260         while (bytes --)
17261           {
17262             unsigned long byte = (* name ++) & 0xff;
17263
17264             val |= byte << shift;
17265             shift += 8;
17266           }
17267
17268         switch (name_attribute)
17269           {
17270           case GNU_BUILD_ATTRIBUTE_PIC:
17271             switch (val)
17272               {
17273               case 0: decoded = "static"; break;
17274               case 1: decoded = "pic"; break;
17275               case 2: decoded = "PIC"; break;
17276               case 3: decoded = "pie"; break;
17277               case 4: decoded = "PIE"; break;
17278               default: break;
17279               }
17280             break;
17281           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17282             switch (val)
17283               {
17284                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17285               case 0: decoded = "off"; break;
17286               case 1: decoded = "on"; break;
17287               case 2: decoded = "all"; break;
17288               case 3: decoded = "strong"; break;
17289               case 4: decoded = "explicit"; break;
17290               default: break;
17291               }
17292             break;
17293           default:
17294             break;
17295           }
17296
17297         if (decoded != NULL)
17298           {
17299             print_symbol (-left, decoded);
17300             left = 0;
17301           }
17302         else if (val == 0)
17303           {
17304             printf ("0x0");
17305             left -= 3;
17306           }
17307         else
17308           {
17309             if (do_wide)
17310               left -= printf ("0x%llx", val);
17311             else
17312               left -= printf ("0x%-.*llx", left, val);
17313           }
17314       }
17315       break;
17316     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17317       left -= print_symbol (- left, name);
17318       break;
17319     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17320       left -= print_symbol (- left, "true");
17321       break;
17322     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17323       left -= print_symbol (- left, "false");
17324       break;
17325     }
17326
17327   if (do_wide && left > 0)
17328     printf ("%-*s", left, " ");
17329
17330   return TRUE;
17331 }
17332
17333 /* Note that by the ELF standard, the name field is already null byte
17334    terminated, and namesz includes the terminating null byte.
17335    I.E. the value of namesz for the name "FSF" is 4.
17336
17337    If the value of namesz is zero, there is no name present.  */
17338
17339 static bfd_boolean
17340 process_note (Elf_Internal_Note *  pnote,
17341               FILE *               file)
17342 {
17343   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17344   const char * nt;
17345
17346   if (pnote->namesz == 0)
17347     /* If there is no note name, then use the default set of
17348        note type strings.  */
17349     nt = get_note_type (pnote->type);
17350
17351   else if (const_strneq (pnote->namedata, "GNU"))
17352     /* GNU-specific object file notes.  */
17353     nt = get_gnu_elf_note_type (pnote->type);
17354
17355   else if (const_strneq (pnote->namedata, "FreeBSD"))
17356     /* FreeBSD-specific core file notes.  */
17357     nt = get_freebsd_elfcore_note_type (pnote->type);
17358
17359   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17360     /* NetBSD-specific core file notes.  */
17361     nt = get_netbsd_elfcore_note_type (pnote->type);
17362
17363   else if (const_strneq (pnote->namedata, "NetBSD"))
17364     /* NetBSD-specific core file notes.  */
17365     return process_netbsd_elf_note (pnote);
17366
17367   else if (strneq (pnote->namedata, "SPU/", 4))
17368     {
17369       /* SPU-specific core file notes.  */
17370       nt = pnote->namedata + 4;
17371       name = "SPU";
17372     }
17373
17374   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17375     /* VMS/ia64-specific file notes.  */
17376     nt = get_ia64_vms_note_type (pnote->type);
17377
17378   else if (const_strneq (pnote->namedata, "stapsdt"))
17379     nt = get_stapsdt_note_type (pnote->type);
17380
17381   else
17382     /* Don't recognize this note name; just use the default set of
17383        note type strings.  */
17384     nt = get_note_type (pnote->type);
17385
17386   printf ("  ");
17387
17388   if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17389       || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17390     print_gnu_build_attribute_name (pnote);
17391   else
17392     print_symbol (-20, name);
17393
17394   if (do_wide)
17395     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17396   else
17397     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17398
17399   if (const_strneq (pnote->namedata, "IPF/VMS"))
17400     return print_ia64_vms_note (pnote);
17401   else if (const_strneq (pnote->namedata, "GNU"))
17402     return print_gnu_note (pnote);
17403   else if (const_strneq (pnote->namedata, "stapsdt"))
17404     return print_stapsdt_note (pnote);
17405   else if (const_strneq (pnote->namedata, "CORE"))
17406     return print_core_note (pnote);
17407   else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17408            || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17409     return print_gnu_build_attribute_description (pnote, file);
17410
17411   if (pnote->descsz)
17412     {
17413       unsigned long i;
17414
17415       printf (_("   description data: "));
17416       for (i = 0; i < pnote->descsz; i++)
17417         printf ("%02x ", pnote->descdata[i]);
17418     }
17419
17420   if (do_wide)
17421     printf ("\n");
17422
17423   return TRUE;
17424 }
17425
17426 static bfd_boolean
17427 process_notes_at (FILE *              file,
17428                   Elf_Internal_Shdr * section,
17429                   bfd_vma             offset,
17430                   bfd_vma             length)
17431 {
17432   Elf_External_Note * pnotes;
17433   Elf_External_Note * external;
17434   char * end;
17435   bfd_boolean res = TRUE;
17436
17437   if (length <= 0)
17438     return FALSE;
17439
17440   if (section)
17441     {
17442       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17443       if (pnotes)
17444         {
17445           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17446             return FALSE;
17447         }
17448     }
17449   else
17450     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17451                                              _("notes"));
17452   if (pnotes == NULL)
17453     return FALSE;
17454
17455   external = pnotes;
17456
17457   if (section)
17458     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17459   else
17460     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17461             (unsigned long) offset, (unsigned long) length);
17462
17463   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17464
17465   end = (char *) pnotes + length;
17466   while ((char *) external < end)
17467     {
17468       Elf_Internal_Note inote;
17469       size_t min_notesz;
17470       char *next;
17471       char * temp = NULL;
17472       size_t data_remaining = end - (char *) external;
17473
17474       if (!is_ia64_vms ())
17475         {
17476           /* PR binutils/15191
17477              Make sure that there is enough data to read.  */
17478           min_notesz = offsetof (Elf_External_Note, name);
17479           if (data_remaining < min_notesz)
17480             {
17481               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17482                     (int) data_remaining);
17483               break;
17484             }
17485           inote.type     = BYTE_GET (external->type);
17486           inote.namesz   = BYTE_GET (external->namesz);
17487           inote.namedata = external->name;
17488           inote.descsz   = BYTE_GET (external->descsz);
17489           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17490           /* PR 17531: file: 3443835e.  */
17491           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17492             {
17493               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17494                     inote.namesz, (long)(end - inote.namedata));
17495               inote.descdata = inote.namedata;
17496               inote.namesz   = 0;
17497             }
17498
17499           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17500           next = inote.descdata + align_power (inote.descsz, 2);
17501         }
17502       else
17503         {
17504           Elf64_External_VMS_Note *vms_external;
17505
17506           /* PR binutils/15191
17507              Make sure that there is enough data to read.  */
17508           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17509           if (data_remaining < min_notesz)
17510             {
17511               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17512                     (int) data_remaining);
17513               break;
17514             }
17515
17516           vms_external = (Elf64_External_VMS_Note *) external;
17517           inote.type     = BYTE_GET (vms_external->type);
17518           inote.namesz   = BYTE_GET (vms_external->namesz);
17519           inote.namedata = vms_external->name;
17520           inote.descsz   = BYTE_GET (vms_external->descsz);
17521           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17522           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17523           next = inote.descdata + align_power (inote.descsz, 3);
17524         }
17525
17526       if (inote.descdata < (char *) external + min_notesz
17527           || next < (char *) external + min_notesz
17528           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17529           || inote.namedata + inote.namesz < inote.namedata
17530           || inote.descdata + inote.descsz < inote.descdata
17531           || data_remaining < (size_t)(next - (char *) external))
17532         {
17533           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17534                 (unsigned long) ((char *) external - (char *) pnotes));
17535           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17536                 inote.type, inote.namesz, inote.descsz);
17537           break;
17538         }
17539
17540       external = (Elf_External_Note *) next;
17541
17542       /* Verify that name is null terminated.  It appears that at least
17543          one version of Linux (RedHat 6.0) generates corefiles that don't
17544          comply with the ELF spec by failing to include the null byte in
17545          namesz.  */
17546       if (inote.namedata[inote.namesz - 1] != '\0')
17547         {
17548           temp = (char *) malloc (inote.namesz + 1);
17549           if (temp == NULL)
17550             {
17551               error (_("Out of memory allocating space for inote name\n"));
17552               res = FALSE;
17553               break;
17554             }
17555
17556           memcpy (temp, inote.namedata, inote.namesz);
17557           temp[inote.namesz] = 0;
17558
17559           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17560           inote.namedata = temp;
17561         }
17562
17563       if (! process_note (& inote, file))
17564         res = FALSE;
17565
17566       if (temp != NULL)
17567         {
17568           free (temp);
17569           temp = NULL;
17570         }
17571     }
17572
17573   free (pnotes);
17574
17575   return res;
17576 }
17577
17578 static bfd_boolean
17579 process_corefile_note_segments (FILE * file)
17580 {
17581   Elf_Internal_Phdr * segment;
17582   unsigned int i;
17583   bfd_boolean res = TRUE;
17584
17585   if (! get_program_headers (file))
17586     return TRUE;
17587
17588   for (i = 0, segment = program_headers;
17589        i < elf_header.e_phnum;
17590        i++, segment++)
17591     {
17592       if (segment->p_type == PT_NOTE)
17593         if (! process_notes_at (file, NULL,
17594                                 (bfd_vma) segment->p_offset,
17595                                 (bfd_vma) segment->p_filesz))
17596           res = FALSE;
17597     }
17598
17599   return res;
17600 }
17601
17602 static bfd_boolean
17603 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17604 {
17605   Elf_External_Note * pnotes;
17606   Elf_External_Note * external;
17607   char * end;
17608   bfd_boolean res = TRUE;
17609
17610   if (length <= 0)
17611     return FALSE;
17612
17613   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17614                                            _("v850 notes"));
17615   if (pnotes == NULL)
17616     return FALSE;
17617
17618   external = pnotes;
17619   end = (char*) pnotes + length;
17620
17621   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17622           (unsigned long) offset, (unsigned long) length);
17623
17624   while ((char *) external + sizeof (Elf_External_Note) < end)
17625     {
17626       Elf_External_Note * next;
17627       Elf_Internal_Note inote;
17628
17629       inote.type     = BYTE_GET (external->type);
17630       inote.namesz   = BYTE_GET (external->namesz);
17631       inote.namedata = external->name;
17632       inote.descsz   = BYTE_GET (external->descsz);
17633       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17634       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17635
17636       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17637         {
17638           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17639           inote.descdata = inote.namedata;
17640           inote.namesz   = 0;
17641         }
17642
17643       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17644
17645       if (   ((char *) next > end)
17646           || ((char *) next <  (char *) pnotes))
17647         {
17648           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17649                 (unsigned long) ((char *) external - (char *) pnotes));
17650           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17651                 inote.type, inote.namesz, inote.descsz);
17652           break;
17653         }
17654
17655       external = next;
17656
17657       /* Prevent out-of-bounds indexing.  */
17658       if (   inote.namedata + inote.namesz > end
17659           || inote.namedata + inote.namesz < inote.namedata)
17660         {
17661           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17662                 (unsigned long) ((char *) external - (char *) pnotes));
17663           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17664                 inote.type, inote.namesz, inote.descsz);
17665           break;
17666         }
17667
17668       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17669
17670       if (! print_v850_note (& inote))
17671         {
17672           res = FALSE;
17673           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17674                   inote.namesz, inote.descsz);
17675         }
17676     }
17677
17678   free (pnotes);
17679
17680   return res;
17681 }
17682
17683 static bfd_boolean
17684 process_note_sections (FILE * file)
17685 {
17686   Elf_Internal_Shdr * section;
17687   unsigned long i;
17688   unsigned int n = 0;
17689   bfd_boolean res = TRUE;
17690
17691   for (i = 0, section = section_headers;
17692        i < elf_header.e_shnum && section != NULL;
17693        i++, section++)
17694     {
17695       if (section->sh_type == SHT_NOTE)
17696         {
17697           if (! process_notes_at (file, section,
17698                                   (bfd_vma) section->sh_offset,
17699                                   (bfd_vma) section->sh_size))
17700             res = FALSE;
17701           n++;
17702         }
17703
17704       if ((   elf_header.e_machine == EM_V800
17705            || elf_header.e_machine == EM_V850
17706            || elf_header.e_machine == EM_CYGNUS_V850)
17707           && section->sh_type == SHT_RENESAS_INFO)
17708         {
17709           if (! process_v850_notes (file,
17710                                     (bfd_vma) section->sh_offset,
17711                                     (bfd_vma) section->sh_size))
17712             res = FALSE;
17713           n++;
17714         }
17715     }
17716
17717   if (n == 0)
17718     /* Try processing NOTE segments instead.  */
17719     return process_corefile_note_segments (file);
17720
17721   return res;
17722 }
17723
17724 static bfd_boolean
17725 process_notes (FILE * file)
17726 {
17727   /* If we have not been asked to display the notes then do nothing.  */
17728   if (! do_notes)
17729     return TRUE;
17730
17731   if (elf_header.e_type != ET_CORE)
17732     return process_note_sections (file);
17733
17734   /* No program headers means no NOTE segment.  */
17735   if (elf_header.e_phnum > 0)
17736     return process_corefile_note_segments (file);
17737
17738   printf (_("No note segments present in the core file.\n"));
17739   return TRUE;
17740 }
17741
17742 static unsigned char *
17743 display_public_gnu_attributes (unsigned char * start,
17744                                const unsigned char * const end)
17745 {
17746   printf (_("  Unknown GNU attribute: %s\n"), start);
17747
17748   start += strnlen ((char *) start, end - start);
17749   display_raw_attribute (start, end);
17750
17751   return (unsigned char *) end;
17752 }
17753
17754 static unsigned char *
17755 display_generic_attribute (unsigned char * start,
17756                            unsigned int tag,
17757                            const unsigned char * const end)
17758 {
17759   if (tag == 0)
17760     return (unsigned char *) end;
17761
17762   return display_tag_value (tag, start, end);
17763 }
17764
17765 static bfd_boolean
17766 process_arch_specific (FILE * file)
17767 {
17768   if (! do_arch)
17769     return TRUE;
17770
17771   switch (elf_header.e_machine)
17772     {
17773     case EM_ARC:
17774     case EM_ARC_COMPACT:
17775     case EM_ARC_COMPACT2:
17776       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17777                                  display_arc_attribute,
17778                                  display_generic_attribute);
17779     case EM_ARM:
17780       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17781                                  display_arm_attribute,
17782                                  display_generic_attribute);
17783
17784     case EM_MIPS:
17785     case EM_MIPS_RS3_LE:
17786       return process_mips_specific (file);
17787
17788     case EM_MSP430:
17789      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17790                                  display_msp430x_attribute,
17791                                  display_generic_attribute);
17792
17793     case EM_NDS32:
17794       return process_nds32_specific (file);
17795
17796     case EM_PPC:
17797     case EM_PPC64:
17798       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17799                                  display_power_gnu_attribute);
17800
17801     case EM_S390:
17802     case EM_S390_OLD:
17803       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17804                                  display_s390_gnu_attribute);
17805
17806     case EM_SPARC:
17807     case EM_SPARC32PLUS:
17808     case EM_SPARCV9:
17809       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17810                                  display_sparc_gnu_attribute);
17811
17812     case EM_TI_C6000:
17813       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17814                                  display_tic6x_attribute,
17815                                  display_generic_attribute);
17816
17817     default:
17818       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17819                                  display_public_gnu_attributes,
17820                                  display_generic_attribute);
17821     }
17822 }
17823
17824 static bfd_boolean
17825 get_file_header (FILE * file)
17826 {
17827   /* Read in the identity array.  */
17828   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17829     return FALSE;
17830
17831   /* Determine how to read the rest of the header.  */
17832   switch (elf_header.e_ident[EI_DATA])
17833     {
17834     default:
17835     case ELFDATANONE:
17836     case ELFDATA2LSB:
17837       byte_get = byte_get_little_endian;
17838       byte_put = byte_put_little_endian;
17839       break;
17840     case ELFDATA2MSB:
17841       byte_get = byte_get_big_endian;
17842       byte_put = byte_put_big_endian;
17843       break;
17844     }
17845
17846   /* For now we only support 32 bit and 64 bit ELF files.  */
17847   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17848
17849   /* Read in the rest of the header.  */
17850   if (is_32bit_elf)
17851     {
17852       Elf32_External_Ehdr ehdr32;
17853
17854       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17855         return FALSE;
17856
17857       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17858       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17859       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17860       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17861       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17862       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17863       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17864       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17865       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17866       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17867       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17868       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17869       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17870     }
17871   else
17872     {
17873       Elf64_External_Ehdr ehdr64;
17874
17875       /* If we have been compiled with sizeof (bfd_vma) == 4, then
17876          we will not be able to cope with the 64bit data found in
17877          64 ELF files.  Detect this now and abort before we start
17878          overwriting things.  */
17879       if (sizeof (bfd_vma) < 8)
17880         {
17881           error (_("This instance of readelf has been built without support for a\n\
17882 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17883           return FALSE;
17884         }
17885
17886       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
17887         return FALSE;
17888
17889       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
17890       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
17891       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
17892       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
17893       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
17894       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
17895       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
17896       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
17897       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17898       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
17899       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17900       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
17901       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
17902     }
17903
17904   if (elf_header.e_shoff)
17905     {
17906       /* There may be some extensions in the first section header.  Don't
17907          bomb if we can't read it.  */
17908       if (is_32bit_elf)
17909         get_32bit_section_headers (file, TRUE);
17910       else
17911         get_64bit_section_headers (file, TRUE);
17912     }
17913
17914   return TRUE;
17915 }
17916
17917 /* Process one ELF object file according to the command line options.
17918    This file may actually be stored in an archive.  The file is
17919    positioned at the start of the ELF object.  Returns TRUE if no
17920    problems were encountered, FALSE otherwise.  */
17921
17922 static bfd_boolean
17923 process_object (char * file_name, FILE * file)
17924 {
17925   unsigned int i;
17926   bfd_boolean res = TRUE;
17927
17928   if (! get_file_header (file))
17929     {
17930       error (_("%s: Failed to read file header\n"), file_name);
17931       return FALSE;
17932     }
17933
17934   /* Initialise per file variables.  */
17935   for (i = ARRAY_SIZE (version_info); i--;)
17936     version_info[i] = 0;
17937
17938   for (i = ARRAY_SIZE (dynamic_info); i--;)
17939     dynamic_info[i] = 0;
17940   dynamic_info_DT_GNU_HASH = 0;
17941
17942   /* Process the file.  */
17943   if (show_name)
17944     printf (_("\nFile: %s\n"), file_name);
17945
17946   /* Initialise the dump_sects array from the cmdline_dump_sects array.
17947      Note we do this even if cmdline_dump_sects is empty because we
17948      must make sure that the dump_sets array is zeroed out before each
17949      object file is processed.  */
17950   if (num_dump_sects > num_cmdline_dump_sects)
17951     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
17952
17953   if (num_cmdline_dump_sects > 0)
17954     {
17955       if (num_dump_sects == 0)
17956         /* A sneaky way of allocating the dump_sects array.  */
17957         request_dump_bynumber (num_cmdline_dump_sects, 0);
17958
17959       assert (num_dump_sects >= num_cmdline_dump_sects);
17960       memcpy (dump_sects, cmdline_dump_sects,
17961               num_cmdline_dump_sects * sizeof (* dump_sects));
17962     }
17963
17964   if (! process_file_header ())
17965     return FALSE;
17966
17967   if (! process_section_headers (file))
17968     {
17969       /* Without loaded section headers we cannot process lots of things.  */
17970       do_unwind = do_version = do_dump = do_arch = FALSE;
17971
17972       if (! do_using_dynamic)
17973         do_syms = do_dyn_syms = do_reloc = FALSE;
17974     }
17975
17976   if (! process_section_groups (file))
17977     /* Without loaded section groups we cannot process unwind.  */
17978     do_unwind = FALSE;
17979
17980   if (process_program_headers (file))
17981     process_dynamic_section (file);
17982   else
17983     res = FALSE;
17984
17985   if (! process_relocs (file))
17986     res = FALSE;
17987
17988   if (! process_unwind (file))
17989     res = FALSE;
17990
17991   if (! process_symbol_table (file))
17992     res = FALSE;
17993
17994   if (! process_syminfo (file))
17995     res = FALSE;
17996
17997   if (! process_version_sections (file))
17998     res = FALSE;
17999
18000   if (! process_section_contents (file))
18001     res = FALSE;
18002
18003   if (! process_notes (file))
18004     res = FALSE;
18005
18006   if (! process_gnu_liblist (file))
18007     res = FALSE;
18008
18009   if (! process_arch_specific (file))
18010     res = FALSE;
18011
18012   if (program_headers)
18013     {
18014       free (program_headers);
18015       program_headers = NULL;
18016     }
18017
18018   if (section_headers)
18019     {
18020       free (section_headers);
18021       section_headers = NULL;
18022     }
18023
18024   if (string_table)
18025     {
18026       free (string_table);
18027       string_table = NULL;
18028       string_table_length = 0;
18029     }
18030
18031   if (dynamic_strings)
18032     {
18033       free (dynamic_strings);
18034       dynamic_strings = NULL;
18035       dynamic_strings_length = 0;
18036     }
18037
18038   if (dynamic_symbols)
18039     {
18040       free (dynamic_symbols);
18041       dynamic_symbols = NULL;
18042       num_dynamic_syms = 0;
18043     }
18044
18045   if (dynamic_syminfo)
18046     {
18047       free (dynamic_syminfo);
18048       dynamic_syminfo = NULL;
18049     }
18050
18051   if (dynamic_section)
18052     {
18053       free (dynamic_section);
18054       dynamic_section = NULL;
18055     }
18056
18057   if (section_headers_groups)
18058     {
18059       free (section_headers_groups);
18060       section_headers_groups = NULL;
18061     }
18062
18063   if (section_groups)
18064     {
18065       struct group_list * g;
18066       struct group_list * next;
18067
18068       for (i = 0; i < group_count; i++)
18069         {
18070           for (g = section_groups [i].root; g != NULL; g = next)
18071             {
18072               next = g->next;
18073               free (g);
18074             }
18075         }
18076
18077       free (section_groups);
18078       section_groups = NULL;
18079     }
18080
18081   free_debug_memory ();
18082
18083   return res;
18084 }
18085
18086 /* Process an ELF archive.
18087    On entry the file is positioned just after the ARMAG string.
18088    Returns TRUE upon success, FALSE otherwise.  */
18089
18090 static bfd_boolean
18091 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18092 {
18093   struct archive_info arch;
18094   struct archive_info nested_arch;
18095   size_t got;
18096   bfd_boolean ret = TRUE;
18097
18098   show_name = TRUE;
18099
18100   /* The ARCH structure is used to hold information about this archive.  */
18101   arch.file_name = NULL;
18102   arch.file = NULL;
18103   arch.index_array = NULL;
18104   arch.sym_table = NULL;
18105   arch.longnames = NULL;
18106
18107   /* The NESTED_ARCH structure is used as a single-item cache of information
18108      about a nested archive (when members of a thin archive reside within
18109      another regular archive file).  */
18110   nested_arch.file_name = NULL;
18111   nested_arch.file = NULL;
18112   nested_arch.index_array = NULL;
18113   nested_arch.sym_table = NULL;
18114   nested_arch.longnames = NULL;
18115
18116   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18117     {
18118       ret = FALSE;
18119       goto out;
18120     }
18121
18122   if (do_archive_index)
18123     {
18124       if (arch.sym_table == NULL)
18125         error (_("%s: unable to dump the index as none was found\n"), file_name);
18126       else
18127         {
18128           unsigned long i, l;
18129           unsigned long current_pos;
18130
18131           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18132                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18133           current_pos = ftell (file);
18134
18135           for (i = l = 0; i < arch.index_num; i++)
18136             {
18137               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18138                 {
18139                   char * member_name;
18140
18141                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18142
18143                   if (member_name != NULL)
18144                     {
18145                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18146
18147                       if (qualified_name != NULL)
18148                         {
18149                           printf (_("Contents of binary %s at offset "), qualified_name);
18150                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18151                           putchar ('\n');
18152                           free (qualified_name);
18153                         }
18154                     }
18155                 }
18156
18157               if (l >= arch.sym_size)
18158                 {
18159                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18160                          file_name);
18161                   ret = FALSE;
18162                   break;
18163                 }
18164               /* PR 17531: file: 0b6630b2.  */
18165               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18166               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18167             }
18168
18169           if (arch.uses_64bit_indicies)
18170             l = (l + 7) & ~ 7;
18171           else
18172             l += l & 1;
18173
18174           if (l < arch.sym_size)
18175             {
18176               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18177                      file_name, arch.sym_size - l);
18178               ret = FALSE;
18179             }
18180
18181           if (fseek (file, current_pos, SEEK_SET) != 0)
18182             {
18183               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18184               ret = FALSE;
18185               goto out;
18186             }
18187         }
18188
18189       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18190           && !do_segments && !do_header && !do_dump && !do_version
18191           && !do_histogram && !do_debugging && !do_arch && !do_notes
18192           && !do_section_groups && !do_dyn_syms)
18193         {
18194           ret = TRUE; /* Archive index only.  */
18195           goto out;
18196         }
18197     }
18198
18199   while (1)
18200     {
18201       char * name;
18202       size_t namelen;
18203       char * qualified_name;
18204
18205       /* Read the next archive header.  */
18206       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18207         {
18208           error (_("%s: failed to seek to next archive header\n"), file_name);
18209           return FALSE;
18210         }
18211       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18212       if (got != sizeof arch.arhdr)
18213         {
18214           if (got == 0)
18215             break;
18216           error (_("%s: failed to read archive header\n"), file_name);
18217           ret = FALSE;
18218           break;
18219         }
18220       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18221         {
18222           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18223           ret = FALSE;
18224           break;
18225         }
18226
18227       arch.next_arhdr_offset += sizeof arch.arhdr;
18228
18229       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18230       if (archive_file_size & 01)
18231         ++archive_file_size;
18232
18233       name = get_archive_member_name (&arch, &nested_arch);
18234       if (name == NULL)
18235         {
18236           error (_("%s: bad archive file name\n"), file_name);
18237           ret = FALSE;
18238           break;
18239         }
18240       namelen = strlen (name);
18241
18242       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18243       if (qualified_name == NULL)
18244         {
18245           error (_("%s: bad archive file name\n"), file_name);
18246           ret = FALSE;
18247           break;
18248         }
18249
18250       if (is_thin_archive && arch.nested_member_origin == 0)
18251         {
18252           /* This is a proxy for an external member of a thin archive.  */
18253           FILE * member_file;
18254           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18255
18256           if (member_file_name == NULL)
18257             {
18258               ret = FALSE;
18259               break;
18260             }
18261
18262           member_file = fopen (member_file_name, "rb");
18263           if (member_file == NULL)
18264             {
18265               error (_("Input file '%s' is not readable.\n"), member_file_name);
18266               free (member_file_name);
18267               ret = FALSE;
18268               break;
18269             }
18270
18271           archive_file_offset = arch.nested_member_origin;
18272
18273           if (! process_object (qualified_name, member_file))
18274             ret = FALSE;
18275
18276           fclose (member_file);
18277           free (member_file_name);
18278         }
18279       else if (is_thin_archive)
18280         {
18281           /* PR 15140: Allow for corrupt thin archives.  */
18282           if (nested_arch.file == NULL)
18283             {
18284               error (_("%s: contains corrupt thin archive: %s\n"),
18285                      file_name, name);
18286               ret = FALSE;
18287               break;
18288             }
18289
18290           /* This is a proxy for a member of a nested archive.  */
18291           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18292
18293           /* The nested archive file will have been opened and setup by
18294              get_archive_member_name.  */
18295           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18296             {
18297               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18298               ret = FALSE;
18299               break;
18300             }
18301
18302           if (! process_object (qualified_name, nested_arch.file))
18303             ret = FALSE;
18304         }
18305       else
18306         {
18307           archive_file_offset = arch.next_arhdr_offset;
18308           arch.next_arhdr_offset += archive_file_size;
18309
18310           if (! process_object (qualified_name, file))
18311             ret = FALSE;
18312         }
18313
18314       if (dump_sects != NULL)
18315         {
18316           free (dump_sects);
18317           dump_sects = NULL;
18318           num_dump_sects = 0;
18319         }
18320
18321       free (qualified_name);
18322     }
18323
18324  out:
18325   if (nested_arch.file != NULL)
18326     fclose (nested_arch.file);
18327   release_archive (&nested_arch);
18328   release_archive (&arch);
18329
18330   return ret;
18331 }
18332
18333 static bfd_boolean
18334 process_file (char * file_name)
18335 {
18336   FILE * file;
18337   struct stat statbuf;
18338   char armag[SARMAG];
18339   bfd_boolean ret = TRUE;
18340
18341   if (stat (file_name, &statbuf) < 0)
18342     {
18343       if (errno == ENOENT)
18344         error (_("'%s': No such file\n"), file_name);
18345       else
18346         error (_("Could not locate '%s'.  System error message: %s\n"),
18347                file_name, strerror (errno));
18348       return FALSE;
18349     }
18350
18351   if (! S_ISREG (statbuf.st_mode))
18352     {
18353       error (_("'%s' is not an ordinary file\n"), file_name);
18354       return FALSE;
18355     }
18356
18357   file = fopen (file_name, "rb");
18358   if (file == NULL)
18359     {
18360       error (_("Input file '%s' is not readable.\n"), file_name);
18361       return FALSE;
18362     }
18363
18364   if (fread (armag, SARMAG, 1, file) != 1)
18365     {
18366       error (_("%s: Failed to read file's magic number\n"), file_name);
18367       fclose (file);
18368       return FALSE;
18369     }
18370
18371   current_file_size = (bfd_size_type) statbuf.st_size;
18372
18373   if (memcmp (armag, ARMAG, SARMAG) == 0)
18374     {
18375       if (! process_archive (file_name, file, FALSE))
18376         ret = FALSE;
18377     }
18378   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18379     {
18380       if ( ! process_archive (file_name, file, TRUE))
18381         ret = FALSE;
18382     }
18383   else
18384     {
18385       if (do_archive_index)
18386         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18387                file_name);
18388
18389       rewind (file);
18390       archive_file_size = archive_file_offset = 0;
18391
18392       if (! process_object (file_name, file))
18393         ret = FALSE;
18394     }
18395
18396   fclose (file);
18397   current_file_size = 0;
18398
18399   return ret;
18400 }
18401
18402 #ifdef SUPPORT_DISASSEMBLY
18403 /* Needed by the i386 disassembler.  For extra credit, someone could
18404    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18405    symbols.  */
18406
18407 void
18408 print_address (unsigned int addr, FILE * outfile)
18409 {
18410   fprintf (outfile,"0x%8.8x", addr);
18411 }
18412
18413 /* Needed by the i386 disassembler.  */
18414 void
18415 db_task_printsym (unsigned int addr)
18416 {
18417   print_address (addr, stderr);
18418 }
18419 #endif
18420
18421 int
18422 main (int argc, char ** argv)
18423 {
18424   int err;
18425
18426 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18427   setlocale (LC_MESSAGES, "");
18428 #endif
18429 #if defined (HAVE_SETLOCALE)
18430   setlocale (LC_CTYPE, "");
18431 #endif
18432   bindtextdomain (PACKAGE, LOCALEDIR);
18433   textdomain (PACKAGE);
18434
18435   expandargv (&argc, &argv);
18436
18437   parse_args (argc, argv);
18438
18439   if (num_dump_sects > 0)
18440     {
18441       /* Make a copy of the dump_sects array.  */
18442       cmdline_dump_sects = (dump_type *)
18443           malloc (num_dump_sects * sizeof (* dump_sects));
18444       if (cmdline_dump_sects == NULL)
18445         error (_("Out of memory allocating dump request table.\n"));
18446       else
18447         {
18448           memcpy (cmdline_dump_sects, dump_sects,
18449                   num_dump_sects * sizeof (* dump_sects));
18450           num_cmdline_dump_sects = num_dump_sects;
18451         }
18452     }
18453
18454   if (optind < (argc - 1))
18455     show_name = TRUE;
18456   else if (optind >= argc)
18457     {
18458       warn (_("Nothing to do.\n"));
18459       usage (stderr);
18460     }
18461
18462   err = FALSE;
18463   while (optind < argc)
18464     if (! process_file (argv[optind++]))
18465       err = TRUE;
18466
18467   if (dump_sects != NULL)
18468     free (dump_sects);
18469   if (cmdline_dump_sects != NULL)
18470     free (cmdline_dump_sects);
18471
18472   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18473 }