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     default:
2512       strcat (buf, ", unrecognised ARC OSABI flag");
2513       break;
2514     }
2515 }
2516
2517 static void
2518 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2519 {
2520   unsigned eabi;
2521   bfd_boolean unknown = FALSE;
2522
2523   eabi = EF_ARM_EABI_VERSION (e_flags);
2524   e_flags &= ~ EF_ARM_EABIMASK;
2525
2526   /* Handle "generic" ARM flags.  */
2527   if (e_flags & EF_ARM_RELEXEC)
2528     {
2529       strcat (buf, ", relocatable executable");
2530       e_flags &= ~ EF_ARM_RELEXEC;
2531     }
2532
2533   /* Now handle EABI specific flags.  */
2534   switch (eabi)
2535     {
2536     default:
2537       strcat (buf, ", <unrecognized EABI>");
2538       if (e_flags)
2539         unknown = TRUE;
2540       break;
2541
2542     case EF_ARM_EABI_VER1:
2543       strcat (buf, ", Version1 EABI");
2544       while (e_flags)
2545         {
2546           unsigned flag;
2547
2548           /* Process flags one bit at a time.  */
2549           flag = e_flags & - e_flags;
2550           e_flags &= ~ flag;
2551
2552           switch (flag)
2553             {
2554             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2555               strcat (buf, ", sorted symbol tables");
2556               break;
2557
2558             default:
2559               unknown = TRUE;
2560               break;
2561             }
2562         }
2563       break;
2564
2565     case EF_ARM_EABI_VER2:
2566       strcat (buf, ", Version2 EABI");
2567       while (e_flags)
2568         {
2569           unsigned flag;
2570
2571           /* Process flags one bit at a time.  */
2572           flag = e_flags & - e_flags;
2573           e_flags &= ~ flag;
2574
2575           switch (flag)
2576             {
2577             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2578               strcat (buf, ", sorted symbol tables");
2579               break;
2580
2581             case EF_ARM_DYNSYMSUSESEGIDX:
2582               strcat (buf, ", dynamic symbols use segment index");
2583               break;
2584
2585             case EF_ARM_MAPSYMSFIRST:
2586               strcat (buf, ", mapping symbols precede others");
2587               break;
2588
2589             default:
2590               unknown = TRUE;
2591               break;
2592             }
2593         }
2594       break;
2595
2596     case EF_ARM_EABI_VER3:
2597       strcat (buf, ", Version3 EABI");
2598       break;
2599
2600     case EF_ARM_EABI_VER4:
2601       strcat (buf, ", Version4 EABI");
2602       while (e_flags)
2603         {
2604           unsigned flag;
2605
2606           /* Process flags one bit at a time.  */
2607           flag = e_flags & - e_flags;
2608           e_flags &= ~ flag;
2609
2610           switch (flag)
2611             {
2612             case EF_ARM_BE8:
2613               strcat (buf, ", BE8");
2614               break;
2615
2616             case EF_ARM_LE8:
2617               strcat (buf, ", LE8");
2618               break;
2619
2620             default:
2621               unknown = TRUE;
2622               break;
2623             }
2624         }
2625       break;
2626
2627     case EF_ARM_EABI_VER5:
2628       strcat (buf, ", Version5 EABI");
2629       while (e_flags)
2630         {
2631           unsigned flag;
2632
2633           /* Process flags one bit at a time.  */
2634           flag = e_flags & - e_flags;
2635           e_flags &= ~ flag;
2636
2637           switch (flag)
2638             {
2639             case EF_ARM_BE8:
2640               strcat (buf, ", BE8");
2641               break;
2642
2643             case EF_ARM_LE8:
2644               strcat (buf, ", LE8");
2645               break;
2646
2647             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2648               strcat (buf, ", soft-float ABI");
2649               break;
2650
2651             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2652               strcat (buf, ", hard-float ABI");
2653               break;
2654
2655             default:
2656               unknown = TRUE;
2657               break;
2658             }
2659         }
2660       break;
2661
2662     case EF_ARM_EABI_UNKNOWN:
2663       strcat (buf, ", GNU EABI");
2664       while (e_flags)
2665         {
2666           unsigned flag;
2667
2668           /* Process flags one bit at a time.  */
2669           flag = e_flags & - e_flags;
2670           e_flags &= ~ flag;
2671
2672           switch (flag)
2673             {
2674             case EF_ARM_INTERWORK:
2675               strcat (buf, ", interworking enabled");
2676               break;
2677
2678             case EF_ARM_APCS_26:
2679               strcat (buf, ", uses APCS/26");
2680               break;
2681
2682             case EF_ARM_APCS_FLOAT:
2683               strcat (buf, ", uses APCS/float");
2684               break;
2685
2686             case EF_ARM_PIC:
2687               strcat (buf, ", position independent");
2688               break;
2689
2690             case EF_ARM_ALIGN8:
2691               strcat (buf, ", 8 bit structure alignment");
2692               break;
2693
2694             case EF_ARM_NEW_ABI:
2695               strcat (buf, ", uses new ABI");
2696               break;
2697
2698             case EF_ARM_OLD_ABI:
2699               strcat (buf, ", uses old ABI");
2700               break;
2701
2702             case EF_ARM_SOFT_FLOAT:
2703               strcat (buf, ", software FP");
2704               break;
2705
2706             case EF_ARM_VFP_FLOAT:
2707               strcat (buf, ", VFP");
2708               break;
2709
2710             case EF_ARM_MAVERICK_FLOAT:
2711               strcat (buf, ", Maverick FP");
2712               break;
2713
2714             default:
2715               unknown = TRUE;
2716               break;
2717             }
2718         }
2719     }
2720
2721   if (unknown)
2722     strcat (buf,_(", <unknown>"));
2723 }
2724
2725 static void
2726 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2727 {
2728   --size; /* Leave space for null terminator.  */
2729
2730   switch (e_flags & EF_AVR_MACH)
2731     {
2732     case E_AVR_MACH_AVR1:
2733       strncat (buf, ", avr:1", size);
2734       break;
2735     case E_AVR_MACH_AVR2:
2736       strncat (buf, ", avr:2", size);
2737       break;
2738     case E_AVR_MACH_AVR25:
2739       strncat (buf, ", avr:25", size);
2740       break;
2741     case E_AVR_MACH_AVR3:
2742       strncat (buf, ", avr:3", size);
2743       break;
2744     case E_AVR_MACH_AVR31:
2745       strncat (buf, ", avr:31", size);
2746       break;
2747     case E_AVR_MACH_AVR35:
2748       strncat (buf, ", avr:35", size);
2749       break;
2750     case E_AVR_MACH_AVR4:
2751       strncat (buf, ", avr:4", size);
2752       break;
2753     case E_AVR_MACH_AVR5:
2754       strncat (buf, ", avr:5", size);
2755       break;
2756     case E_AVR_MACH_AVR51:
2757       strncat (buf, ", avr:51", size);
2758       break;
2759     case E_AVR_MACH_AVR6:
2760       strncat (buf, ", avr:6", size);
2761       break;
2762     case E_AVR_MACH_AVRTINY:
2763       strncat (buf, ", avr:100", size);
2764       break;
2765     case E_AVR_MACH_XMEGA1:
2766       strncat (buf, ", avr:101", size);
2767       break;
2768     case E_AVR_MACH_XMEGA2:
2769       strncat (buf, ", avr:102", size);
2770       break;
2771     case E_AVR_MACH_XMEGA3:
2772       strncat (buf, ", avr:103", size);
2773       break;
2774     case E_AVR_MACH_XMEGA4:
2775       strncat (buf, ", avr:104", size);
2776       break;
2777     case E_AVR_MACH_XMEGA5:
2778       strncat (buf, ", avr:105", size);
2779       break;
2780     case E_AVR_MACH_XMEGA6:
2781       strncat (buf, ", avr:106", size);
2782       break;
2783     case E_AVR_MACH_XMEGA7:
2784       strncat (buf, ", avr:107", size);
2785       break;
2786     default:
2787       strncat (buf, ", avr:<unknown>", size);
2788       break;
2789     }
2790
2791   size -= strlen (buf);
2792   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2793     strncat (buf, ", link-relax", size);
2794 }
2795
2796 static void
2797 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2798 {
2799   unsigned abi;
2800   unsigned arch;
2801   unsigned config;
2802   unsigned version;
2803   bfd_boolean has_fpu = FALSE;
2804   unsigned int r = 0;
2805
2806   static const char *ABI_STRINGS[] =
2807   {
2808     "ABI v0", /* use r5 as return register; only used in N1213HC */
2809     "ABI v1", /* use r0 as return register */
2810     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2811     "ABI v2fp", /* for FPU */
2812     "AABI",
2813     "ABI2 FP+"
2814   };
2815   static const char *VER_STRINGS[] =
2816   {
2817     "Andes ELF V1.3 or older",
2818     "Andes ELF V1.3.1",
2819     "Andes ELF V1.4"
2820   };
2821   static const char *ARCH_STRINGS[] =
2822   {
2823     "",
2824     "Andes Star v1.0",
2825     "Andes Star v2.0",
2826     "Andes Star v3.0",
2827     "Andes Star v3.0m"
2828   };
2829
2830   abi = EF_NDS_ABI & e_flags;
2831   arch = EF_NDS_ARCH & e_flags;
2832   config = EF_NDS_INST & e_flags;
2833   version = EF_NDS32_ELF_VERSION & e_flags;
2834
2835   memset (buf, 0, size);
2836
2837   switch (abi)
2838     {
2839     case E_NDS_ABI_V0:
2840     case E_NDS_ABI_V1:
2841     case E_NDS_ABI_V2:
2842     case E_NDS_ABI_V2FP:
2843     case E_NDS_ABI_AABI:
2844     case E_NDS_ABI_V2FP_PLUS:
2845       /* In case there are holes in the array.  */
2846       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2847       break;
2848
2849     default:
2850       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2851       break;
2852     }
2853
2854   switch (version)
2855     {
2856     case E_NDS32_ELF_VER_1_2:
2857     case E_NDS32_ELF_VER_1_3:
2858     case E_NDS32_ELF_VER_1_4:
2859       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2860       break;
2861
2862     default:
2863       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2864       break;
2865     }
2866
2867   if (E_NDS_ABI_V0 == abi)
2868     {
2869       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2870       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2871       if (arch == E_NDS_ARCH_STAR_V1_0)
2872         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2873       return;
2874     }
2875
2876   switch (arch)
2877     {
2878     case E_NDS_ARCH_STAR_V1_0:
2879     case E_NDS_ARCH_STAR_V2_0:
2880     case E_NDS_ARCH_STAR_V3_0:
2881     case E_NDS_ARCH_STAR_V3_M:
2882       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2883       break;
2884
2885     default:
2886       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2887       /* ARCH version determines how the e_flags are interpreted.
2888          If it is unknown, we cannot proceed.  */
2889       return;
2890     }
2891
2892   /* Newer ABI; Now handle architecture specific flags.  */
2893   if (arch == E_NDS_ARCH_STAR_V1_0)
2894     {
2895       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2896         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2897
2898       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2899         r += snprintf (buf + r, size -r, ", MAC");
2900
2901       if (config & E_NDS32_HAS_DIV_INST)
2902         r += snprintf (buf + r, size -r, ", DIV");
2903
2904       if (config & E_NDS32_HAS_16BIT_INST)
2905         r += snprintf (buf + r, size -r, ", 16b");
2906     }
2907   else
2908     {
2909       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2910         {
2911           if (version <= E_NDS32_ELF_VER_1_3)
2912             r += snprintf (buf + r, size -r, ", [B8]");
2913           else
2914             r += snprintf (buf + r, size -r, ", EX9");
2915         }
2916
2917       if (config & E_NDS32_HAS_MAC_DX_INST)
2918         r += snprintf (buf + r, size -r, ", MAC_DX");
2919
2920       if (config & E_NDS32_HAS_DIV_DX_INST)
2921         r += snprintf (buf + r, size -r, ", DIV_DX");
2922
2923       if (config & E_NDS32_HAS_16BIT_INST)
2924         {
2925           if (version <= E_NDS32_ELF_VER_1_3)
2926             r += snprintf (buf + r, size -r, ", 16b");
2927           else
2928             r += snprintf (buf + r, size -r, ", IFC");
2929         }
2930     }
2931
2932   if (config & E_NDS32_HAS_EXT_INST)
2933     r += snprintf (buf + r, size -r, ", PERF1");
2934
2935   if (config & E_NDS32_HAS_EXT2_INST)
2936     r += snprintf (buf + r, size -r, ", PERF2");
2937
2938   if (config & E_NDS32_HAS_FPU_INST)
2939     {
2940       has_fpu = TRUE;
2941       r += snprintf (buf + r, size -r, ", FPU_SP");
2942     }
2943
2944   if (config & E_NDS32_HAS_FPU_DP_INST)
2945     {
2946       has_fpu = TRUE;
2947       r += snprintf (buf + r, size -r, ", FPU_DP");
2948     }
2949
2950   if (config & E_NDS32_HAS_FPU_MAC_INST)
2951     {
2952       has_fpu = TRUE;
2953       r += snprintf (buf + r, size -r, ", FPU_MAC");
2954     }
2955
2956   if (has_fpu)
2957     {
2958       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2959         {
2960         case E_NDS32_FPU_REG_8SP_4DP:
2961           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2962           break;
2963         case E_NDS32_FPU_REG_16SP_8DP:
2964           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2965           break;
2966         case E_NDS32_FPU_REG_32SP_16DP:
2967           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2968           break;
2969         case E_NDS32_FPU_REG_32SP_32DP:
2970           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2971           break;
2972         }
2973     }
2974
2975   if (config & E_NDS32_HAS_AUDIO_INST)
2976     r += snprintf (buf + r, size -r, ", AUDIO");
2977
2978   if (config & E_NDS32_HAS_STRING_INST)
2979     r += snprintf (buf + r, size -r, ", STR");
2980
2981   if (config & E_NDS32_HAS_REDUCED_REGS)
2982     r += snprintf (buf + r, size -r, ", 16REG");
2983
2984   if (config & E_NDS32_HAS_VIDEO_INST)
2985     {
2986       if (version <= E_NDS32_ELF_VER_1_3)
2987         r += snprintf (buf + r, size -r, ", VIDEO");
2988       else
2989         r += snprintf (buf + r, size -r, ", SATURATION");
2990     }
2991
2992   if (config & E_NDS32_HAS_ENCRIPT_INST)
2993     r += snprintf (buf + r, size -r, ", ENCRP");
2994
2995   if (config & E_NDS32_HAS_L2C_INST)
2996     r += snprintf (buf + r, size -r, ", L2C");
2997 }
2998
2999 static char *
3000 get_machine_flags (unsigned e_flags, unsigned e_machine)
3001 {
3002   static char buf[1024];
3003
3004   buf[0] = '\0';
3005
3006   if (e_flags)
3007     {
3008       switch (e_machine)
3009         {
3010         default:
3011           break;
3012
3013         case EM_ARC_COMPACT2:
3014         case EM_ARC_COMPACT:
3015           decode_ARC_machine_flags (e_flags, e_machine, buf);
3016           break;
3017
3018         case EM_ARM:
3019           decode_ARM_machine_flags (e_flags, buf);
3020           break;
3021
3022         case EM_AVR:
3023           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3024           break;
3025
3026         case EM_BLACKFIN:
3027           if (e_flags & EF_BFIN_PIC)
3028             strcat (buf, ", PIC");
3029
3030           if (e_flags & EF_BFIN_FDPIC)
3031             strcat (buf, ", FDPIC");
3032
3033           if (e_flags & EF_BFIN_CODE_IN_L1)
3034             strcat (buf, ", code in L1");
3035
3036           if (e_flags & EF_BFIN_DATA_IN_L1)
3037             strcat (buf, ", data in L1");
3038
3039           break;
3040
3041         case EM_CYGNUS_FRV:
3042           switch (e_flags & EF_FRV_CPU_MASK)
3043             {
3044             case EF_FRV_CPU_GENERIC:
3045               break;
3046
3047             default:
3048               strcat (buf, ", fr???");
3049               break;
3050
3051             case EF_FRV_CPU_FR300:
3052               strcat (buf, ", fr300");
3053               break;
3054
3055             case EF_FRV_CPU_FR400:
3056               strcat (buf, ", fr400");
3057               break;
3058             case EF_FRV_CPU_FR405:
3059               strcat (buf, ", fr405");
3060               break;
3061
3062             case EF_FRV_CPU_FR450:
3063               strcat (buf, ", fr450");
3064               break;
3065
3066             case EF_FRV_CPU_FR500:
3067               strcat (buf, ", fr500");
3068               break;
3069             case EF_FRV_CPU_FR550:
3070               strcat (buf, ", fr550");
3071               break;
3072
3073             case EF_FRV_CPU_SIMPLE:
3074               strcat (buf, ", simple");
3075               break;
3076             case EF_FRV_CPU_TOMCAT:
3077               strcat (buf, ", tomcat");
3078               break;
3079             }
3080           break;
3081
3082         case EM_68K:
3083           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3084             strcat (buf, ", m68000");
3085           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3086             strcat (buf, ", cpu32");
3087           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3088             strcat (buf, ", fido_a");
3089           else
3090             {
3091               char const * isa = _("unknown");
3092               char const * mac = _("unknown mac");
3093               char const * additional = NULL;
3094
3095               switch (e_flags & EF_M68K_CF_ISA_MASK)
3096                 {
3097                 case EF_M68K_CF_ISA_A_NODIV:
3098                   isa = "A";
3099                   additional = ", nodiv";
3100                   break;
3101                 case EF_M68K_CF_ISA_A:
3102                   isa = "A";
3103                   break;
3104                 case EF_M68K_CF_ISA_A_PLUS:
3105                   isa = "A+";
3106                   break;
3107                 case EF_M68K_CF_ISA_B_NOUSP:
3108                   isa = "B";
3109                   additional = ", nousp";
3110                   break;
3111                 case EF_M68K_CF_ISA_B:
3112                   isa = "B";
3113                   break;
3114                 case EF_M68K_CF_ISA_C:
3115                   isa = "C";
3116                   break;
3117                 case EF_M68K_CF_ISA_C_NODIV:
3118                   isa = "C";
3119                   additional = ", nodiv";
3120                   break;
3121                 }
3122               strcat (buf, ", cf, isa ");
3123               strcat (buf, isa);
3124               if (additional)
3125                 strcat (buf, additional);
3126               if (e_flags & EF_M68K_CF_FLOAT)
3127                 strcat (buf, ", float");
3128               switch (e_flags & EF_M68K_CF_MAC_MASK)
3129                 {
3130                 case 0:
3131                   mac = NULL;
3132                   break;
3133                 case EF_M68K_CF_MAC:
3134                   mac = "mac";
3135                   break;
3136                 case EF_M68K_CF_EMAC:
3137                   mac = "emac";
3138                   break;
3139                 case EF_M68K_CF_EMAC_B:
3140                   mac = "emac_b";
3141                   break;
3142                 }
3143               if (mac)
3144                 {
3145                   strcat (buf, ", ");
3146                   strcat (buf, mac);
3147                 }
3148             }
3149           break;
3150
3151         case EM_CYGNUS_MEP:
3152           switch (e_flags & EF_MEP_CPU_MASK)
3153             {
3154             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3155             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3156             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3157             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3158             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3159             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3160             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3161             }
3162
3163           switch (e_flags & EF_MEP_COP_MASK)
3164             {
3165             case EF_MEP_COP_NONE: break;
3166             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3167             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3168             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3169             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3170             default: strcat (buf, _("<unknown MeP copro type>")); break;
3171             }
3172
3173           if (e_flags & EF_MEP_LIBRARY)
3174             strcat (buf, ", Built for Library");
3175
3176           if (e_flags & EF_MEP_INDEX_MASK)
3177             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3178                      e_flags & EF_MEP_INDEX_MASK);
3179
3180           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3181             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3182                      e_flags & ~ EF_MEP_ALL_FLAGS);
3183           break;
3184
3185         case EM_PPC:
3186           if (e_flags & EF_PPC_EMB)
3187             strcat (buf, ", emb");
3188
3189           if (e_flags & EF_PPC_RELOCATABLE)
3190             strcat (buf, _(", relocatable"));
3191
3192           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3193             strcat (buf, _(", relocatable-lib"));
3194           break;
3195
3196         case EM_PPC64:
3197           if (e_flags & EF_PPC64_ABI)
3198             {
3199               char abi[] = ", abiv0";
3200
3201               abi[6] += e_flags & EF_PPC64_ABI;
3202               strcat (buf, abi);
3203             }
3204           break;
3205
3206         case EM_V800:
3207           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3208             strcat (buf, ", RH850 ABI");
3209
3210           if (e_flags & EF_V800_850E3)
3211             strcat (buf, ", V3 architecture");
3212
3213           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3214             strcat (buf, ", FPU not used");
3215
3216           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3217             strcat (buf, ", regmode: COMMON");
3218
3219           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3220             strcat (buf, ", r4 not used");
3221
3222           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3223             strcat (buf, ", r30 not used");
3224
3225           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3226             strcat (buf, ", r5 not used");
3227
3228           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3229             strcat (buf, ", r2 not used");
3230
3231           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3232             {
3233               switch (e_flags & - e_flags)
3234                 {
3235                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3236                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3237                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3238                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3239                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3240                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3241                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3242                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3243                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3244                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3245                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3246                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3247                 default: break;
3248                 }
3249             }
3250           break;
3251
3252         case EM_V850:
3253         case EM_CYGNUS_V850:
3254           switch (e_flags & EF_V850_ARCH)
3255             {
3256             case E_V850E3V5_ARCH:
3257               strcat (buf, ", v850e3v5");
3258               break;
3259             case E_V850E2V3_ARCH:
3260               strcat (buf, ", v850e2v3");
3261               break;
3262             case E_V850E2_ARCH:
3263               strcat (buf, ", v850e2");
3264               break;
3265             case E_V850E1_ARCH:
3266               strcat (buf, ", v850e1");
3267               break;
3268             case E_V850E_ARCH:
3269               strcat (buf, ", v850e");
3270               break;
3271             case E_V850_ARCH:
3272               strcat (buf, ", v850");
3273               break;
3274             default:
3275               strcat (buf, _(", unknown v850 architecture variant"));
3276               break;
3277             }
3278           break;
3279
3280         case EM_M32R:
3281         case EM_CYGNUS_M32R:
3282           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3283             strcat (buf, ", m32r");
3284           break;
3285
3286         case EM_MIPS:
3287         case EM_MIPS_RS3_LE:
3288           if (e_flags & EF_MIPS_NOREORDER)
3289             strcat (buf, ", noreorder");
3290
3291           if (e_flags & EF_MIPS_PIC)
3292             strcat (buf, ", pic");
3293
3294           if (e_flags & EF_MIPS_CPIC)
3295             strcat (buf, ", cpic");
3296
3297           if (e_flags & EF_MIPS_UCODE)
3298             strcat (buf, ", ugen_reserved");
3299
3300           if (e_flags & EF_MIPS_ABI2)
3301             strcat (buf, ", abi2");
3302
3303           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3304             strcat (buf, ", odk first");
3305
3306           if (e_flags & EF_MIPS_32BITMODE)
3307             strcat (buf, ", 32bitmode");
3308
3309           if (e_flags & EF_MIPS_NAN2008)
3310             strcat (buf, ", nan2008");
3311
3312           if (e_flags & EF_MIPS_FP64)
3313             strcat (buf, ", fp64");
3314
3315           switch ((e_flags & EF_MIPS_MACH))
3316             {
3317             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3318             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3319             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3320             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3321             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3322             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3323             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3324             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3325             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3326             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3327             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3328             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3329             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3330             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3331             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3332             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3333             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3334             case 0:
3335             /* We simply ignore the field in this case to avoid confusion:
3336                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3337                extension.  */
3338               break;
3339             default: strcat (buf, _(", unknown CPU")); break;
3340             }
3341
3342           switch ((e_flags & EF_MIPS_ABI))
3343             {
3344             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3345             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3346             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3347             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3348             case 0:
3349             /* We simply ignore the field in this case to avoid confusion:
3350                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3351                This means it is likely to be an o32 file, but not for
3352                sure.  */
3353               break;
3354             default: strcat (buf, _(", unknown ABI")); break;
3355             }
3356
3357           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3358             strcat (buf, ", mdmx");
3359
3360           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3361             strcat (buf, ", mips16");
3362
3363           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3364             strcat (buf, ", micromips");
3365
3366           switch ((e_flags & EF_MIPS_ARCH))
3367             {
3368             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3369             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3370             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3371             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3372             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3373             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3374             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3375             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3376             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3377             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3378             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3379             default: strcat (buf, _(", unknown ISA")); break;
3380             }
3381           break;
3382
3383         case EM_NDS32:
3384           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3385           break;
3386
3387         case EM_RISCV:
3388           if (e_flags & EF_RISCV_RVC)
3389             strcat (buf, ", RVC");
3390
3391           switch (e_flags & EF_RISCV_FLOAT_ABI)
3392             {
3393             case EF_RISCV_FLOAT_ABI_SOFT:
3394               strcat (buf, ", soft-float ABI");
3395               break;
3396
3397             case EF_RISCV_FLOAT_ABI_SINGLE:
3398               strcat (buf, ", single-float ABI");
3399               break;
3400
3401             case EF_RISCV_FLOAT_ABI_DOUBLE:
3402               strcat (buf, ", double-float ABI");
3403               break;
3404
3405             case EF_RISCV_FLOAT_ABI_QUAD:
3406               strcat (buf, ", quad-float ABI");
3407               break;
3408             }
3409           break;
3410
3411         case EM_SH:
3412           switch ((e_flags & EF_SH_MACH_MASK))
3413             {
3414             case EF_SH1: strcat (buf, ", sh1"); break;
3415             case EF_SH2: strcat (buf, ", sh2"); break;
3416             case EF_SH3: strcat (buf, ", sh3"); break;
3417             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3418             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3419             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3420             case EF_SH3E: strcat (buf, ", sh3e"); break;
3421             case EF_SH4: strcat (buf, ", sh4"); break;
3422             case EF_SH5: strcat (buf, ", sh5"); break;
3423             case EF_SH2E: strcat (buf, ", sh2e"); break;
3424             case EF_SH4A: strcat (buf, ", sh4a"); break;
3425             case EF_SH2A: strcat (buf, ", sh2a"); break;
3426             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3427             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3428             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3429             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3430             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3431             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3432             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3433             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3434             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3435             default: strcat (buf, _(", unknown ISA")); break;
3436             }
3437
3438           if (e_flags & EF_SH_PIC)
3439             strcat (buf, ", pic");
3440
3441           if (e_flags & EF_SH_FDPIC)
3442             strcat (buf, ", fdpic");
3443           break;
3444
3445         case EM_OR1K:
3446           if (e_flags & EF_OR1K_NODELAY)
3447             strcat (buf, ", no delay");
3448           break;
3449
3450         case EM_SPARCV9:
3451           if (e_flags & EF_SPARC_32PLUS)
3452             strcat (buf, ", v8+");
3453
3454           if (e_flags & EF_SPARC_SUN_US1)
3455             strcat (buf, ", ultrasparcI");
3456
3457           if (e_flags & EF_SPARC_SUN_US3)
3458             strcat (buf, ", ultrasparcIII");
3459
3460           if (e_flags & EF_SPARC_HAL_R1)
3461             strcat (buf, ", halr1");
3462
3463           if (e_flags & EF_SPARC_LEDATA)
3464             strcat (buf, ", ledata");
3465
3466           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3467             strcat (buf, ", tso");
3468
3469           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3470             strcat (buf, ", pso");
3471
3472           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3473             strcat (buf, ", rmo");
3474           break;
3475
3476         case EM_PARISC:
3477           switch (e_flags & EF_PARISC_ARCH)
3478             {
3479             case EFA_PARISC_1_0:
3480               strcpy (buf, ", PA-RISC 1.0");
3481               break;
3482             case EFA_PARISC_1_1:
3483               strcpy (buf, ", PA-RISC 1.1");
3484               break;
3485             case EFA_PARISC_2_0:
3486               strcpy (buf, ", PA-RISC 2.0");
3487               break;
3488             default:
3489               break;
3490             }
3491           if (e_flags & EF_PARISC_TRAPNIL)
3492             strcat (buf, ", trapnil");
3493           if (e_flags & EF_PARISC_EXT)
3494             strcat (buf, ", ext");
3495           if (e_flags & EF_PARISC_LSB)
3496             strcat (buf, ", lsb");
3497           if (e_flags & EF_PARISC_WIDE)
3498             strcat (buf, ", wide");
3499           if (e_flags & EF_PARISC_NO_KABP)
3500             strcat (buf, ", no kabp");
3501           if (e_flags & EF_PARISC_LAZYSWAP)
3502             strcat (buf, ", lazyswap");
3503           break;
3504
3505         case EM_PJ:
3506         case EM_PJ_OLD:
3507           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3508             strcat (buf, ", new calling convention");
3509
3510           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3511             strcat (buf, ", gnu calling convention");
3512           break;
3513
3514         case EM_IA_64:
3515           if ((e_flags & EF_IA_64_ABI64))
3516             strcat (buf, ", 64-bit");
3517           else
3518             strcat (buf, ", 32-bit");
3519           if ((e_flags & EF_IA_64_REDUCEDFP))
3520             strcat (buf, ", reduced fp model");
3521           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3522             strcat (buf, ", no function descriptors, constant gp");
3523           else if ((e_flags & EF_IA_64_CONS_GP))
3524             strcat (buf, ", constant gp");
3525           if ((e_flags & EF_IA_64_ABSOLUTE))
3526             strcat (buf, ", absolute");
3527           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3528             {
3529               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3530                 strcat (buf, ", vms_linkages");
3531               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3532                 {
3533                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3534                   break;
3535                 case EF_IA_64_VMS_COMCOD_WARNING:
3536                   strcat (buf, ", warning");
3537                   break;
3538                 case EF_IA_64_VMS_COMCOD_ERROR:
3539                   strcat (buf, ", error");
3540                   break;
3541                 case EF_IA_64_VMS_COMCOD_ABORT:
3542                   strcat (buf, ", abort");
3543                   break;
3544                 default:
3545                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3546                         e_flags & EF_IA_64_VMS_COMCOD);
3547                   strcat (buf, ", <unknown>");
3548                 }
3549             }
3550           break;
3551
3552         case EM_VAX:
3553           if ((e_flags & EF_VAX_NONPIC))
3554             strcat (buf, ", non-PIC");
3555           if ((e_flags & EF_VAX_DFLOAT))
3556             strcat (buf, ", D-Float");
3557           if ((e_flags & EF_VAX_GFLOAT))
3558             strcat (buf, ", G-Float");
3559           break;
3560
3561         case EM_VISIUM:
3562           if (e_flags & EF_VISIUM_ARCH_MCM)
3563             strcat (buf, ", mcm");
3564           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3565             strcat (buf, ", mcm24");
3566           if (e_flags & EF_VISIUM_ARCH_GR6)
3567             strcat (buf, ", gr6");
3568           break;
3569
3570         case EM_RL78:
3571           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3572             {
3573             case E_FLAG_RL78_ANY_CPU: break;
3574             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3575             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3576             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3577             }
3578           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3579             strcat (buf, ", 64-bit doubles");
3580           break;
3581
3582         case EM_RX:
3583           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3584             strcat (buf, ", 64-bit doubles");
3585           if (e_flags & E_FLAG_RX_DSP)
3586             strcat (buf, ", dsp");
3587           if (e_flags & E_FLAG_RX_PID)
3588             strcat (buf, ", pid");
3589           if (e_flags & E_FLAG_RX_ABI)
3590             strcat (buf, ", RX ABI");
3591           if (e_flags & E_FLAG_RX_SINSNS_SET)
3592             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3593                     ? ", uses String instructions" : ", bans String instructions");
3594           if (e_flags & E_FLAG_RX_V2)
3595             strcat (buf, ", V2");
3596           break;
3597
3598         case EM_S390:
3599           if (e_flags & EF_S390_HIGH_GPRS)
3600             strcat (buf, ", highgprs");
3601           break;
3602
3603         case EM_TI_C6000:
3604           if ((e_flags & EF_C6000_REL))
3605             strcat (buf, ", relocatable module");
3606           break;
3607
3608         case EM_MSP430:
3609           strcat (buf, _(": architecture variant: "));
3610           switch (e_flags & EF_MSP430_MACH)
3611             {
3612             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3613             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3614             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3615             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3616             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3617             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3618             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3619             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3620             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3621             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3622             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3623             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3624             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3625             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3626             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3627             default:
3628               strcat (buf, _(": unknown")); break;
3629             }
3630
3631           if (e_flags & ~ EF_MSP430_MACH)
3632             strcat (buf, _(": unknown extra flag bits also present"));
3633         }
3634     }
3635
3636   return buf;
3637 }
3638
3639 static const char *
3640 get_osabi_name (unsigned int osabi)
3641 {
3642   static char buff[32];
3643
3644   switch (osabi)
3645     {
3646     case ELFOSABI_NONE:         return "UNIX - System V";
3647     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3648     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3649     case ELFOSABI_GNU:          return "UNIX - GNU";
3650     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3651     case ELFOSABI_AIX:          return "UNIX - AIX";
3652     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3653     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3654     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3655     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3656     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3657     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3658     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3659     case ELFOSABI_AROS:         return "AROS";
3660     case ELFOSABI_FENIXOS:      return "FenixOS";
3661     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3662     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3663     default:
3664       if (osabi >= 64)
3665         switch (elf_header.e_machine)
3666           {
3667           case EM_ARM:
3668             switch (osabi)
3669               {
3670               case ELFOSABI_ARM:        return "ARM";
3671               default:
3672                 break;
3673               }
3674             break;
3675
3676           case EM_MSP430:
3677           case EM_MSP430_OLD:
3678           case EM_VISIUM:
3679             switch (osabi)
3680               {
3681               case ELFOSABI_STANDALONE: return _("Standalone App");
3682               default:
3683                 break;
3684               }
3685             break;
3686
3687           case EM_TI_C6000:
3688             switch (osabi)
3689               {
3690               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3691               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3692               default:
3693                 break;
3694               }
3695             break;
3696
3697           default:
3698             break;
3699           }
3700       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3701       return buff;
3702     }
3703 }
3704
3705 static const char *
3706 get_aarch64_segment_type (unsigned long type)
3707 {
3708   switch (type)
3709     {
3710     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3711     default:                  return NULL;
3712     }
3713 }
3714
3715 static const char *
3716 get_arm_segment_type (unsigned long type)
3717 {
3718   switch (type)
3719     {
3720     case PT_ARM_EXIDX: return "EXIDX";
3721     default:           return NULL;
3722     }
3723 }
3724
3725 static const char *
3726 get_mips_segment_type (unsigned long type)
3727 {
3728   switch (type)
3729     {
3730     case PT_MIPS_REGINFO:   return "REGINFO";
3731     case PT_MIPS_RTPROC:    return "RTPROC";
3732     case PT_MIPS_OPTIONS:   return "OPTIONS";
3733     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3734     default:                return NULL;
3735     }
3736 }
3737
3738 static const char *
3739 get_parisc_segment_type (unsigned long type)
3740 {
3741   switch (type)
3742     {
3743     case PT_HP_TLS:             return "HP_TLS";
3744     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3745     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3746     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3747     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3748     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3749     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3750     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3751     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3752     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3753     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3754     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3755     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3756     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3757     case PT_HP_STACK:           return "HP_STACK";
3758     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3759     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3760     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3761     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3762     default:                    return NULL;
3763     }
3764 }
3765
3766 static const char *
3767 get_ia64_segment_type (unsigned long type)
3768 {
3769   switch (type)
3770     {
3771     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3772     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3773     case PT_HP_TLS:             return "HP_TLS";
3774     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3775     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3776     case PT_IA_64_HP_STACK:     return "HP_STACK";
3777     default:                    return NULL;
3778     }
3779 }
3780
3781 static const char *
3782 get_tic6x_segment_type (unsigned long type)
3783 {
3784   switch (type)
3785     {
3786     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3787     default:               return NULL;
3788     }
3789 }
3790
3791 static const char *
3792 get_solaris_segment_type (unsigned long type)
3793 {
3794   switch (type)
3795     {
3796     case 0x6464e550: return "PT_SUNW_UNWIND";
3797     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3798     case 0x6ffffff7: return "PT_LOSUNW";
3799     case 0x6ffffffa: return "PT_SUNWBSS";
3800     case 0x6ffffffb: return "PT_SUNWSTACK";
3801     case 0x6ffffffc: return "PT_SUNWDTRACE";
3802     case 0x6ffffffd: return "PT_SUNWCAP";
3803     case 0x6fffffff: return "PT_HISUNW";
3804     default:         return NULL;
3805     }
3806 }
3807
3808 static const char *
3809 get_segment_type (unsigned long p_type)
3810 {
3811   static char buff[32];
3812
3813   switch (p_type)
3814     {
3815     case PT_NULL:       return "NULL";
3816     case PT_LOAD:       return "LOAD";
3817     case PT_DYNAMIC:    return "DYNAMIC";
3818     case PT_INTERP:     return "INTERP";
3819     case PT_NOTE:       return "NOTE";
3820     case PT_SHLIB:      return "SHLIB";
3821     case PT_PHDR:       return "PHDR";
3822     case PT_TLS:        return "TLS";
3823     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3824     case PT_GNU_STACK:  return "GNU_STACK";
3825     case PT_GNU_RELRO:  return "GNU_RELRO";
3826
3827     default:
3828       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3829         {
3830           sprintf (buff, "GNU_MBIND+%#lx",
3831                    p_type - PT_GNU_MBIND_LO);
3832         }
3833       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3834         {
3835           const char * result;
3836
3837           switch (elf_header.e_machine)
3838             {
3839             case EM_AARCH64:
3840               result = get_aarch64_segment_type (p_type);
3841               break;
3842             case EM_ARM:
3843               result = get_arm_segment_type (p_type);
3844               break;
3845             case EM_MIPS:
3846             case EM_MIPS_RS3_LE:
3847               result = get_mips_segment_type (p_type);
3848               break;
3849             case EM_PARISC:
3850               result = get_parisc_segment_type (p_type);
3851               break;
3852             case EM_IA_64:
3853               result = get_ia64_segment_type (p_type);
3854               break;
3855             case EM_TI_C6000:
3856               result = get_tic6x_segment_type (p_type);
3857               break;
3858             default:
3859               result = NULL;
3860               break;
3861             }
3862
3863           if (result != NULL)
3864             return result;
3865
3866           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3867         }
3868       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3869         {
3870           const char * result;
3871
3872           switch (elf_header.e_machine)
3873             {
3874             case EM_PARISC:
3875               result = get_parisc_segment_type (p_type);
3876               break;
3877             case EM_IA_64:
3878               result = get_ia64_segment_type (p_type);
3879               break;
3880             default:
3881               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3882                 result = get_solaris_segment_type (p_type);
3883               else
3884                 result = NULL;
3885               break;
3886             }
3887
3888           if (result != NULL)
3889             return result;
3890
3891           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3892         }
3893       else
3894         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3895
3896       return buff;
3897     }
3898 }
3899
3900 static const char *
3901 get_mips_section_type_name (unsigned int sh_type)
3902 {
3903   switch (sh_type)
3904     {
3905     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3906     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3907     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3908     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3909     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3910     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3911     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3912     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3913     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3914     case SHT_MIPS_RELD:          return "MIPS_RELD";
3915     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3916     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3917     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3918     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3919     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3920     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3921     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3922     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3923     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3924     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3925     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3926     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3927     case SHT_MIPS_LINE:          return "MIPS_LINE";
3928     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3929     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3930     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3931     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3932     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3933     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3934     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3935     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3936     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3937     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3938     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3939     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3940     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3941     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3942     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3943     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3944     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3945     default:
3946       break;
3947     }
3948   return NULL;
3949 }
3950
3951 static const char *
3952 get_parisc_section_type_name (unsigned int sh_type)
3953 {
3954   switch (sh_type)
3955     {
3956     case SHT_PARISC_EXT:        return "PARISC_EXT";
3957     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3958     case SHT_PARISC_DOC:        return "PARISC_DOC";
3959     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3960     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3961     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3962     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3963     default:                    return NULL;
3964     }
3965 }
3966
3967 static const char *
3968 get_ia64_section_type_name (unsigned int sh_type)
3969 {
3970   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
3971   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3972     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3973
3974   switch (sh_type)
3975     {
3976     case SHT_IA_64_EXT:                return "IA_64_EXT";
3977     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
3978     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
3979     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
3980     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3981     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
3982     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
3983     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
3984     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
3985     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
3986     default:
3987       break;
3988     }
3989   return NULL;
3990 }
3991
3992 static const char *
3993 get_x86_64_section_type_name (unsigned int sh_type)
3994 {
3995   switch (sh_type)
3996     {
3997     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
3998     default:                    return NULL;
3999     }
4000 }
4001
4002 static const char *
4003 get_aarch64_section_type_name (unsigned int sh_type)
4004 {
4005   switch (sh_type)
4006     {
4007     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4008     default:                     return NULL;
4009     }
4010 }
4011
4012 static const char *
4013 get_arm_section_type_name (unsigned int sh_type)
4014 {
4015   switch (sh_type)
4016     {
4017     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4018     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4019     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4020     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4021     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4022     default:                      return NULL;
4023     }
4024 }
4025
4026 static const char *
4027 get_tic6x_section_type_name (unsigned int sh_type)
4028 {
4029   switch (sh_type)
4030     {
4031     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4032     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4033     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4034     case SHT_TI_ICODE:          return "TI_ICODE";
4035     case SHT_TI_XREF:           return "TI_XREF";
4036     case SHT_TI_HANDLER:        return "TI_HANDLER";
4037     case SHT_TI_INITINFO:       return "TI_INITINFO";
4038     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4039     default:                    return NULL;
4040     }
4041 }
4042
4043 static const char *
4044 get_msp430x_section_type_name (unsigned int sh_type)
4045 {
4046   switch (sh_type)
4047     {
4048     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4049     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4050     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4051     default:                      return NULL;
4052     }
4053 }
4054
4055 static const char *
4056 get_v850_section_type_name (unsigned int sh_type)
4057 {
4058   switch (sh_type)
4059     {
4060     case SHT_V850_SCOMMON:  return "V850 Small Common";
4061     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4062     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4063     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4064     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4065     default:                return NULL;
4066     }
4067 }
4068
4069 static const char *
4070 get_section_type_name (unsigned int sh_type)
4071 {
4072   static char buff[32];
4073   const char * result;
4074
4075   switch (sh_type)
4076     {
4077     case SHT_NULL:              return "NULL";
4078     case SHT_PROGBITS:          return "PROGBITS";
4079     case SHT_SYMTAB:            return "SYMTAB";
4080     case SHT_STRTAB:            return "STRTAB";
4081     case SHT_RELA:              return "RELA";
4082     case SHT_HASH:              return "HASH";
4083     case SHT_DYNAMIC:           return "DYNAMIC";
4084     case SHT_NOTE:              return "NOTE";
4085     case SHT_NOBITS:            return "NOBITS";
4086     case SHT_REL:               return "REL";
4087     case SHT_SHLIB:             return "SHLIB";
4088     case SHT_DYNSYM:            return "DYNSYM";
4089     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4090     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4091     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4092     case SHT_GNU_HASH:          return "GNU_HASH";
4093     case SHT_GROUP:             return "GROUP";
4094     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4095     case SHT_GNU_verdef:        return "VERDEF";
4096     case SHT_GNU_verneed:       return "VERNEED";
4097     case SHT_GNU_versym:        return "VERSYM";
4098     case 0x6ffffff0:            return "VERSYM";
4099     case 0x6ffffffc:            return "VERDEF";
4100     case 0x7ffffffd:            return "AUXILIARY";
4101     case 0x7fffffff:            return "FILTER";
4102     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4103
4104     default:
4105       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4106         {
4107           switch (elf_header.e_machine)
4108             {
4109             case EM_MIPS:
4110             case EM_MIPS_RS3_LE:
4111               result = get_mips_section_type_name (sh_type);
4112               break;
4113             case EM_PARISC:
4114               result = get_parisc_section_type_name (sh_type);
4115               break;
4116             case EM_IA_64:
4117               result = get_ia64_section_type_name (sh_type);
4118               break;
4119             case EM_X86_64:
4120             case EM_L1OM:
4121             case EM_K1OM:
4122               result = get_x86_64_section_type_name (sh_type);
4123               break;
4124             case EM_AARCH64:
4125               result = get_aarch64_section_type_name (sh_type);
4126               break;
4127             case EM_ARM:
4128               result = get_arm_section_type_name (sh_type);
4129               break;
4130             case EM_TI_C6000:
4131               result = get_tic6x_section_type_name (sh_type);
4132               break;
4133             case EM_MSP430:
4134               result = get_msp430x_section_type_name (sh_type);
4135               break;
4136             case EM_V800:
4137             case EM_V850:
4138             case EM_CYGNUS_V850:
4139               result = get_v850_section_type_name (sh_type);
4140               break;
4141             default:
4142               result = NULL;
4143               break;
4144             }
4145
4146           if (result != NULL)
4147             return result;
4148
4149           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4150         }
4151       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4152         {
4153           switch (elf_header.e_machine)
4154             {
4155             case EM_IA_64:
4156               result = get_ia64_section_type_name (sh_type);
4157               break;
4158             default:
4159               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4160                 result = get_solaris_section_type (sh_type);
4161               else
4162                 {
4163                   switch (sh_type)
4164                     {
4165                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4166                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4167                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4168                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4169                     default:
4170                       result = NULL;
4171                       break;
4172                     }
4173                 }
4174               break;
4175             }
4176
4177           if (result != NULL)
4178             return result;
4179
4180           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4181         }
4182       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4183         {
4184           switch (elf_header.e_machine)
4185             {
4186             case EM_V800:
4187             case EM_V850:
4188             case EM_CYGNUS_V850:
4189               result = get_v850_section_type_name (sh_type);
4190               break;
4191             default:
4192               result = NULL;
4193               break;
4194             }
4195
4196           if (result != NULL)
4197             return result;
4198
4199           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4200         }
4201       else
4202         /* This message is probably going to be displayed in a 15
4203            character wide field, so put the hex value first.  */
4204         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4205
4206       return buff;
4207     }
4208 }
4209
4210 #define OPTION_DEBUG_DUMP       512
4211 #define OPTION_DYN_SYMS         513
4212 #define OPTION_DWARF_DEPTH      514
4213 #define OPTION_DWARF_START      515
4214 #define OPTION_DWARF_CHECK      516
4215
4216 static struct option options[] =
4217 {
4218   {"all",              no_argument, 0, 'a'},
4219   {"file-header",      no_argument, 0, 'h'},
4220   {"program-headers",  no_argument, 0, 'l'},
4221   {"headers",          no_argument, 0, 'e'},
4222   {"histogram",        no_argument, 0, 'I'},
4223   {"segments",         no_argument, 0, 'l'},
4224   {"sections",         no_argument, 0, 'S'},
4225   {"section-headers",  no_argument, 0, 'S'},
4226   {"section-groups",   no_argument, 0, 'g'},
4227   {"section-details",  no_argument, 0, 't'},
4228   {"full-section-name",no_argument, 0, 'N'},
4229   {"symbols",          no_argument, 0, 's'},
4230   {"syms",             no_argument, 0, 's'},
4231   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4232   {"relocs",           no_argument, 0, 'r'},
4233   {"notes",            no_argument, 0, 'n'},
4234   {"dynamic",          no_argument, 0, 'd'},
4235   {"arch-specific",    no_argument, 0, 'A'},
4236   {"version-info",     no_argument, 0, 'V'},
4237   {"use-dynamic",      no_argument, 0, 'D'},
4238   {"unwind",           no_argument, 0, 'u'},
4239   {"archive-index",    no_argument, 0, 'c'},
4240   {"hex-dump",         required_argument, 0, 'x'},
4241   {"relocated-dump",   required_argument, 0, 'R'},
4242   {"string-dump",      required_argument, 0, 'p'},
4243   {"decompress",       no_argument, 0, 'z'},
4244 #ifdef SUPPORT_DISASSEMBLY
4245   {"instruction-dump", required_argument, 0, 'i'},
4246 #endif
4247   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4248
4249   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4250   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4251   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4252
4253   {"version",          no_argument, 0, 'v'},
4254   {"wide",             no_argument, 0, 'W'},
4255   {"help",             no_argument, 0, 'H'},
4256   {0,                  no_argument, 0, 0}
4257 };
4258
4259 static void
4260 usage (FILE * stream)
4261 {
4262   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4263   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4264   fprintf (stream, _(" Options are:\n\
4265   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4266   -h --file-header       Display the ELF file header\n\
4267   -l --program-headers   Display the program headers\n\
4268      --segments          An alias for --program-headers\n\
4269   -S --section-headers   Display the sections' header\n\
4270      --sections          An alias for --section-headers\n\
4271   -g --section-groups    Display the section groups\n\
4272   -t --section-details   Display the section details\n\
4273   -e --headers           Equivalent to: -h -l -S\n\
4274   -s --syms              Display the symbol table\n\
4275      --symbols           An alias for --syms\n\
4276   --dyn-syms             Display the dynamic symbol table\n\
4277   -n --notes             Display the core notes (if present)\n\
4278   -r --relocs            Display the relocations (if present)\n\
4279   -u --unwind            Display the unwind info (if present)\n\
4280   -d --dynamic           Display the dynamic section (if present)\n\
4281   -V --version-info      Display the version sections (if present)\n\
4282   -A --arch-specific     Display architecture specific information (if any)\n\
4283   -c --archive-index     Display the symbol/file index in an archive\n\
4284   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4285   -x --hex-dump=<number|name>\n\
4286                          Dump the contents of section <number|name> as bytes\n\
4287   -p --string-dump=<number|name>\n\
4288                          Dump the contents of section <number|name> as strings\n\
4289   -R --relocated-dump=<number|name>\n\
4290                          Dump the contents of section <number|name> as relocated bytes\n\
4291   -z --decompress        Decompress section before dumping it\n\
4292   -w[lLiaprmfFsoRt] or\n\
4293   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4294                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4295                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4296                =addr,=cu_index]\n\
4297                          Display the contents of DWARF2 debug sections\n"));
4298   fprintf (stream, _("\
4299   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4300   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4301                          or deeper\n"));
4302 #ifdef SUPPORT_DISASSEMBLY
4303   fprintf (stream, _("\
4304   -i --instruction-dump=<number|name>\n\
4305                          Disassemble the contents of section <number|name>\n"));
4306 #endif
4307   fprintf (stream, _("\
4308   -I --histogram         Display histogram of bucket list lengths\n\
4309   -W --wide              Allow output width to exceed 80 characters\n\
4310   @<file>                Read options from <file>\n\
4311   -H --help              Display this information\n\
4312   -v --version           Display the version number of readelf\n"));
4313
4314   if (REPORT_BUGS_TO[0] && stream == stdout)
4315     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4316
4317   exit (stream == stdout ? 0 : 1);
4318 }
4319
4320 /* Record the fact that the user wants the contents of section number
4321    SECTION to be displayed using the method(s) encoded as flags bits
4322    in TYPE.  Note, TYPE can be zero if we are creating the array for
4323    the first time.  */
4324
4325 static void
4326 request_dump_bynumber (unsigned int section, dump_type type)
4327 {
4328   if (section >= num_dump_sects)
4329     {
4330       dump_type * new_dump_sects;
4331
4332       new_dump_sects = (dump_type *) calloc (section + 1,
4333                                              sizeof (* dump_sects));
4334
4335       if (new_dump_sects == NULL)
4336         error (_("Out of memory allocating dump request table.\n"));
4337       else
4338         {
4339           if (dump_sects)
4340             {
4341               /* Copy current flag settings.  */
4342               memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4343
4344               free (dump_sects);
4345             }
4346
4347           dump_sects = new_dump_sects;
4348           num_dump_sects = section + 1;
4349         }
4350     }
4351
4352   if (dump_sects)
4353     dump_sects[section] |= type;
4354
4355   return;
4356 }
4357
4358 /* Request a dump by section name.  */
4359
4360 static void
4361 request_dump_byname (const char * section, dump_type type)
4362 {
4363   struct dump_list_entry * new_request;
4364
4365   new_request = (struct dump_list_entry *)
4366       malloc (sizeof (struct dump_list_entry));
4367   if (!new_request)
4368     error (_("Out of memory allocating dump request table.\n"));
4369
4370   new_request->name = strdup (section);
4371   if (!new_request->name)
4372     error (_("Out of memory allocating dump request table.\n"));
4373
4374   new_request->type = type;
4375
4376   new_request->next = dump_sects_byname;
4377   dump_sects_byname = new_request;
4378 }
4379
4380 static inline void
4381 request_dump (dump_type type)
4382 {
4383   int section;
4384   char * cp;
4385
4386   do_dump++;
4387   section = strtoul (optarg, & cp, 0);
4388
4389   if (! *cp && section >= 0)
4390     request_dump_bynumber (section, type);
4391   else
4392     request_dump_byname (optarg, type);
4393 }
4394
4395
4396 static void
4397 parse_args (int argc, char ** argv)
4398 {
4399   int c;
4400
4401   if (argc < 2)
4402     usage (stderr);
4403
4404   while ((c = getopt_long
4405           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4406     {
4407       switch (c)
4408         {
4409         case 0:
4410           /* Long options.  */
4411           break;
4412         case 'H':
4413           usage (stdout);
4414           break;
4415
4416         case 'a':
4417           do_syms = TRUE;
4418           do_reloc = TRUE;
4419           do_unwind = TRUE;
4420           do_dynamic = TRUE;
4421           do_header = TRUE;
4422           do_sections = TRUE;
4423           do_section_groups = TRUE;
4424           do_segments = TRUE;
4425           do_version = TRUE;
4426           do_histogram = TRUE;
4427           do_arch = TRUE;
4428           do_notes = TRUE;
4429           break;
4430         case 'g':
4431           do_section_groups = TRUE;
4432           break;
4433         case 't':
4434         case 'N':
4435           do_sections = TRUE;
4436           do_section_details = TRUE;
4437           break;
4438         case 'e':
4439           do_header = TRUE;
4440           do_sections = TRUE;
4441           do_segments = TRUE;
4442           break;
4443         case 'A':
4444           do_arch = TRUE;
4445           break;
4446         case 'D':
4447           do_using_dynamic = TRUE;
4448           break;
4449         case 'r':
4450           do_reloc = TRUE;
4451           break;
4452         case 'u':
4453           do_unwind = TRUE;
4454           break;
4455         case 'h':
4456           do_header = TRUE;
4457           break;
4458         case 'l':
4459           do_segments = TRUE;
4460           break;
4461         case 's':
4462           do_syms = TRUE;
4463           break;
4464         case 'S':
4465           do_sections = TRUE;
4466           break;
4467         case 'd':
4468           do_dynamic = TRUE;
4469           break;
4470         case 'I':
4471           do_histogram = TRUE;
4472           break;
4473         case 'n':
4474           do_notes = TRUE;
4475           break;
4476         case 'c':
4477           do_archive_index = TRUE;
4478           break;
4479         case 'x':
4480           request_dump (HEX_DUMP);
4481           break;
4482         case 'p':
4483           request_dump (STRING_DUMP);
4484           break;
4485         case 'R':
4486           request_dump (RELOC_DUMP);
4487           break;
4488         case 'z':
4489           decompress_dumps = TRUE;
4490           break;
4491         case 'w':
4492           do_dump = TRUE;
4493           if (optarg == 0)
4494             {
4495               do_debugging = TRUE;
4496               dwarf_select_sections_all ();
4497             }
4498           else
4499             {
4500               do_debugging = FALSE;
4501               dwarf_select_sections_by_letters (optarg);
4502             }
4503           break;
4504         case OPTION_DEBUG_DUMP:
4505           do_dump = TRUE;
4506           if (optarg == 0)
4507             do_debugging = TRUE;
4508           else
4509             {
4510               do_debugging = FALSE;
4511               dwarf_select_sections_by_names (optarg);
4512             }
4513           break;
4514         case OPTION_DWARF_DEPTH:
4515           {
4516             char *cp;
4517
4518             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4519           }
4520           break;
4521         case OPTION_DWARF_START:
4522           {
4523             char *cp;
4524
4525             dwarf_start_die = strtoul (optarg, & cp, 0);
4526           }
4527           break;
4528         case OPTION_DWARF_CHECK:
4529           dwarf_check = TRUE;
4530           break;
4531         case OPTION_DYN_SYMS:
4532           do_dyn_syms = TRUE;
4533           break;
4534 #ifdef SUPPORT_DISASSEMBLY
4535         case 'i':
4536           request_dump (DISASS_DUMP);
4537           break;
4538 #endif
4539         case 'v':
4540           print_version (program_name);
4541           break;
4542         case 'V':
4543           do_version = TRUE;
4544           break;
4545         case 'W':
4546           do_wide = TRUE;
4547           break;
4548         default:
4549           /* xgettext:c-format */
4550           error (_("Invalid option '-%c'\n"), c);
4551           /* Fall through.  */
4552         case '?':
4553           usage (stderr);
4554         }
4555     }
4556
4557   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4558       && !do_segments && !do_header && !do_dump && !do_version
4559       && !do_histogram && !do_debugging && !do_arch && !do_notes
4560       && !do_section_groups && !do_archive_index
4561       && !do_dyn_syms)
4562     usage (stderr);
4563 }
4564
4565 static const char *
4566 get_elf_class (unsigned int elf_class)
4567 {
4568   static char buff[32];
4569
4570   switch (elf_class)
4571     {
4572     case ELFCLASSNONE: return _("none");
4573     case ELFCLASS32:   return "ELF32";
4574     case ELFCLASS64:   return "ELF64";
4575     default:
4576       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4577       return buff;
4578     }
4579 }
4580
4581 static const char *
4582 get_data_encoding (unsigned int encoding)
4583 {
4584   static char buff[32];
4585
4586   switch (encoding)
4587     {
4588     case ELFDATANONE: return _("none");
4589     case ELFDATA2LSB: return _("2's complement, little endian");
4590     case ELFDATA2MSB: return _("2's complement, big endian");
4591     default:
4592       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4593       return buff;
4594     }
4595 }
4596
4597 /* Decode the data held in 'elf_header'.  */
4598
4599 static bfd_boolean
4600 process_file_header (void)
4601 {
4602   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4603       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4604       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4605       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4606     {
4607       error
4608         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4609       return FALSE;
4610     }
4611
4612   init_dwarf_regnames (elf_header.e_machine);
4613
4614   if (do_header)
4615     {
4616       unsigned i;
4617
4618       printf (_("ELF Header:\n"));
4619       printf (_("  Magic:   "));
4620       for (i = 0; i < EI_NIDENT; i++)
4621         printf ("%2.2x ", elf_header.e_ident[i]);
4622       printf ("\n");
4623       printf (_("  Class:                             %s\n"),
4624               get_elf_class (elf_header.e_ident[EI_CLASS]));
4625       printf (_("  Data:                              %s\n"),
4626               get_data_encoding (elf_header.e_ident[EI_DATA]));
4627       printf (_("  Version:                           %d %s\n"),
4628               elf_header.e_ident[EI_VERSION],
4629               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4630                ? "(current)"
4631                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4632                   ? _("<unknown: %lx>")
4633                   : "")));
4634       printf (_("  OS/ABI:                            %s\n"),
4635               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4636       printf (_("  ABI Version:                       %d\n"),
4637               elf_header.e_ident[EI_ABIVERSION]);
4638       printf (_("  Type:                              %s\n"),
4639               get_file_type (elf_header.e_type));
4640       printf (_("  Machine:                           %s\n"),
4641               get_machine_name (elf_header.e_machine));
4642       printf (_("  Version:                           0x%lx\n"),
4643               (unsigned long) elf_header.e_version);
4644
4645       printf (_("  Entry point address:               "));
4646       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4647       printf (_("\n  Start of program headers:          "));
4648       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4649       printf (_(" (bytes into file)\n  Start of section headers:          "));
4650       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4651       printf (_(" (bytes into file)\n"));
4652
4653       printf (_("  Flags:                             0x%lx%s\n"),
4654               (unsigned long) elf_header.e_flags,
4655               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4656       printf (_("  Size of this header:               %ld (bytes)\n"),
4657               (long) elf_header.e_ehsize);
4658       printf (_("  Size of program headers:           %ld (bytes)\n"),
4659               (long) elf_header.e_phentsize);
4660       printf (_("  Number of program headers:         %ld"),
4661               (long) elf_header.e_phnum);
4662       if (section_headers != NULL
4663           && elf_header.e_phnum == PN_XNUM
4664           && section_headers[0].sh_info != 0)
4665         printf (" (%ld)", (long) section_headers[0].sh_info);
4666       putc ('\n', stdout);
4667       printf (_("  Size of section headers:           %ld (bytes)\n"),
4668               (long) elf_header.e_shentsize);
4669       printf (_("  Number of section headers:         %ld"),
4670               (long) elf_header.e_shnum);
4671       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4672         printf (" (%ld)", (long) section_headers[0].sh_size);
4673       putc ('\n', stdout);
4674       printf (_("  Section header string table index: %ld"),
4675               (long) elf_header.e_shstrndx);
4676       if (section_headers != NULL
4677           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4678         printf (" (%u)", section_headers[0].sh_link);
4679       else if (elf_header.e_shstrndx != SHN_UNDEF
4680                && elf_header.e_shstrndx >= elf_header.e_shnum)
4681         printf (_(" <corrupt: out of range>"));
4682       putc ('\n', stdout);
4683     }
4684
4685   if (section_headers != NULL)
4686     {
4687       if (elf_header.e_phnum == PN_XNUM
4688           && section_headers[0].sh_info != 0)
4689         elf_header.e_phnum = section_headers[0].sh_info;
4690       if (elf_header.e_shnum == SHN_UNDEF)
4691         elf_header.e_shnum = section_headers[0].sh_size;
4692       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4693         elf_header.e_shstrndx = section_headers[0].sh_link;
4694       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4695         elf_header.e_shstrndx = SHN_UNDEF;
4696       free (section_headers);
4697       section_headers = NULL;
4698     }
4699
4700   return TRUE;
4701 }
4702
4703 static bfd_boolean
4704 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4705 {
4706   Elf32_External_Phdr * phdrs;
4707   Elf32_External_Phdr * external;
4708   Elf_Internal_Phdr *   internal;
4709   unsigned int i;
4710   unsigned int size = elf_header.e_phentsize;
4711   unsigned int num  = elf_header.e_phnum;
4712
4713   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4714   if (size == 0 || num == 0)
4715     return FALSE;
4716   if (size < sizeof * phdrs)
4717     {
4718       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4719       return FALSE;
4720     }
4721   if (size > sizeof * phdrs)
4722     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4723
4724   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4725                                             size, num, _("program headers"));
4726   if (phdrs == NULL)
4727     return FALSE;
4728
4729   for (i = 0, internal = pheaders, external = phdrs;
4730        i < elf_header.e_phnum;
4731        i++, internal++, external++)
4732     {
4733       internal->p_type   = BYTE_GET (external->p_type);
4734       internal->p_offset = BYTE_GET (external->p_offset);
4735       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4736       internal->p_paddr  = BYTE_GET (external->p_paddr);
4737       internal->p_filesz = BYTE_GET (external->p_filesz);
4738       internal->p_memsz  = BYTE_GET (external->p_memsz);
4739       internal->p_flags  = BYTE_GET (external->p_flags);
4740       internal->p_align  = BYTE_GET (external->p_align);
4741     }
4742
4743   free (phdrs);
4744   return TRUE;
4745 }
4746
4747 static bfd_boolean
4748 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4749 {
4750   Elf64_External_Phdr * phdrs;
4751   Elf64_External_Phdr * external;
4752   Elf_Internal_Phdr *   internal;
4753   unsigned int i;
4754   unsigned int size = elf_header.e_phentsize;
4755   unsigned int num  = elf_header.e_phnum;
4756
4757   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4758   if (size == 0 || num == 0)
4759     return FALSE;
4760   if (size < sizeof * phdrs)
4761     {
4762       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4763       return FALSE;
4764     }
4765   if (size > sizeof * phdrs)
4766     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4767
4768   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4769                                             size, num, _("program headers"));
4770   if (!phdrs)
4771     return FALSE;
4772
4773   for (i = 0, internal = pheaders, external = phdrs;
4774        i < elf_header.e_phnum;
4775        i++, internal++, external++)
4776     {
4777       internal->p_type   = BYTE_GET (external->p_type);
4778       internal->p_flags  = BYTE_GET (external->p_flags);
4779       internal->p_offset = BYTE_GET (external->p_offset);
4780       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4781       internal->p_paddr  = BYTE_GET (external->p_paddr);
4782       internal->p_filesz = BYTE_GET (external->p_filesz);
4783       internal->p_memsz  = BYTE_GET (external->p_memsz);
4784       internal->p_align  = BYTE_GET (external->p_align);
4785     }
4786
4787   free (phdrs);
4788   return TRUE;
4789 }
4790
4791 /* Returns TRUE if the program headers were read into `program_headers'.  */
4792
4793 static bfd_boolean
4794 get_program_headers (FILE * file)
4795 {
4796   Elf_Internal_Phdr * phdrs;
4797
4798   /* Check cache of prior read.  */
4799   if (program_headers != NULL)
4800     return TRUE;
4801
4802   /* Be kind to memory checkers by looking for
4803      e_phnum values which we know must be invalid.  */
4804   if (elf_header.e_phnum
4805       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4806       >= current_file_size)
4807     {
4808       error (_("Too many program headers - %#x - the file is not that big\n"),
4809              elf_header.e_phnum);
4810       return FALSE;
4811     }
4812
4813   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4814                                          sizeof (Elf_Internal_Phdr));
4815   if (phdrs == NULL)
4816     {
4817       error (_("Out of memory reading %u program headers\n"),
4818              elf_header.e_phnum);
4819       return FALSE;
4820     }
4821
4822   if (is_32bit_elf
4823       ? get_32bit_program_headers (file, phdrs)
4824       : get_64bit_program_headers (file, phdrs))
4825     {
4826       program_headers = phdrs;
4827       return TRUE;
4828     }
4829
4830   free (phdrs);
4831   return FALSE;
4832 }
4833
4834 /* Returns TRUE if the program headers were loaded.  */
4835
4836 static bfd_boolean
4837 process_program_headers (FILE * file)
4838 {
4839   Elf_Internal_Phdr * segment;
4840   unsigned int i;
4841   Elf_Internal_Phdr * previous_load = NULL;
4842
4843   if (elf_header.e_phnum == 0)
4844     {
4845       /* PR binutils/12467.  */
4846       if (elf_header.e_phoff != 0)
4847         {
4848           warn (_("possibly corrupt ELF header - it has a non-zero program"
4849                   " header offset, but no program headers\n"));
4850           return FALSE;
4851         }
4852       else if (do_segments)
4853         printf (_("\nThere are no program headers in this file.\n"));
4854       return TRUE;
4855     }
4856
4857   if (do_segments && !do_header)
4858     {
4859       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4860       printf (_("Entry point "));
4861       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4862       printf (_("\nThere are %d program headers, starting at offset "),
4863               elf_header.e_phnum);
4864       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4865       printf ("\n");
4866     }
4867
4868   if (! get_program_headers (file))
4869     return TRUE;
4870
4871   if (do_segments)
4872     {
4873       if (elf_header.e_phnum > 1)
4874         printf (_("\nProgram Headers:\n"));
4875       else
4876         printf (_("\nProgram Headers:\n"));
4877
4878       if (is_32bit_elf)
4879         printf
4880           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4881       else if (do_wide)
4882         printf
4883           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4884       else
4885         {
4886           printf
4887             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4888           printf
4889             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4890         }
4891     }
4892
4893   dynamic_addr = 0;
4894   dynamic_size = 0;
4895
4896   for (i = 0, segment = program_headers;
4897        i < elf_header.e_phnum;
4898        i++, segment++)
4899     {
4900       if (do_segments)
4901         {
4902           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4903
4904           if (is_32bit_elf)
4905             {
4906               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4907               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4908               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4909               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4910               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4911               printf ("%c%c%c ",
4912                       (segment->p_flags & PF_R ? 'R' : ' '),
4913                       (segment->p_flags & PF_W ? 'W' : ' '),
4914                       (segment->p_flags & PF_X ? 'E' : ' '));
4915               printf ("%#lx", (unsigned long) segment->p_align);
4916             }
4917           else if (do_wide)
4918             {
4919               if ((unsigned long) segment->p_offset == segment->p_offset)
4920                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4921               else
4922                 {
4923                   print_vma (segment->p_offset, FULL_HEX);
4924                   putchar (' ');
4925                 }
4926
4927               print_vma (segment->p_vaddr, FULL_HEX);
4928               putchar (' ');
4929               print_vma (segment->p_paddr, FULL_HEX);
4930               putchar (' ');
4931
4932               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4933                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4934               else
4935                 {
4936                   print_vma (segment->p_filesz, FULL_HEX);
4937                   putchar (' ');
4938                 }
4939
4940               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4941                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4942               else
4943                 {
4944                   print_vma (segment->p_memsz, FULL_HEX);
4945                 }
4946
4947               printf (" %c%c%c ",
4948                       (segment->p_flags & PF_R ? 'R' : ' '),
4949                       (segment->p_flags & PF_W ? 'W' : ' '),
4950                       (segment->p_flags & PF_X ? 'E' : ' '));
4951
4952               if ((unsigned long) segment->p_align == segment->p_align)
4953                 printf ("%#lx", (unsigned long) segment->p_align);
4954               else
4955                 {
4956                   print_vma (segment->p_align, PREFIX_HEX);
4957                 }
4958             }
4959           else
4960             {
4961               print_vma (segment->p_offset, FULL_HEX);
4962               putchar (' ');
4963               print_vma (segment->p_vaddr, FULL_HEX);
4964               putchar (' ');
4965               print_vma (segment->p_paddr, FULL_HEX);
4966               printf ("\n                 ");
4967               print_vma (segment->p_filesz, FULL_HEX);
4968               putchar (' ');
4969               print_vma (segment->p_memsz, FULL_HEX);
4970               printf ("  %c%c%c    ",
4971                       (segment->p_flags & PF_R ? 'R' : ' '),
4972                       (segment->p_flags & PF_W ? 'W' : ' '),
4973                       (segment->p_flags & PF_X ? 'E' : ' '));
4974               print_vma (segment->p_align, PREFIX_HEX);
4975             }
4976
4977           putc ('\n', stdout);
4978         }
4979
4980       switch (segment->p_type)
4981         {
4982         case PT_LOAD:
4983 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
4984          required by the ELF standard, several programs, including the Linux
4985          kernel, make use of non-ordered segments.  */
4986           if (previous_load
4987               && previous_load->p_vaddr > segment->p_vaddr)
4988             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4989 #endif
4990           if (segment->p_memsz < segment->p_filesz)
4991             error (_("the segment's file size is larger than its memory size\n"));
4992           previous_load = segment;
4993           break;
4994
4995         case PT_PHDR:
4996           /* PR 20815 - Verify that the program header is loaded into memory.  */
4997           if (i > 0 && previous_load != NULL)
4998             error (_("the PHDR segment must occur before any LOAD segment\n"));
4999           if (elf_header.e_machine != EM_PARISC)
5000             {
5001               unsigned int j;
5002
5003               for (j = 1; j < elf_header.e_phnum; j++)
5004                 if (program_headers[j].p_vaddr <= segment->p_vaddr
5005                     && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5006                     >= (segment->p_vaddr + segment->p_filesz))
5007                   break;
5008               if (j == elf_header.e_phnum)
5009                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5010             }
5011           break;
5012
5013         case PT_DYNAMIC:
5014           if (dynamic_addr)
5015             error (_("more than one dynamic segment\n"));
5016
5017           /* By default, assume that the .dynamic section is the first
5018              section in the DYNAMIC segment.  */
5019           dynamic_addr = segment->p_offset;
5020           dynamic_size = segment->p_filesz;
5021
5022           /* Try to locate the .dynamic section. If there is
5023              a section header table, we can easily locate it.  */
5024           if (section_headers != NULL)
5025             {
5026               Elf_Internal_Shdr * sec;
5027
5028               sec = find_section (".dynamic");
5029               if (sec == NULL || sec->sh_size == 0)
5030                 {
5031                   /* A corresponding .dynamic section is expected, but on
5032                      IA-64/OpenVMS it is OK for it to be missing.  */
5033                   if (!is_ia64_vms ())
5034                     error (_("no .dynamic section in the dynamic segment\n"));
5035                   break;
5036                 }
5037
5038               if (sec->sh_type == SHT_NOBITS)
5039                 {
5040                   dynamic_size = 0;
5041                   break;
5042                 }
5043
5044               dynamic_addr = sec->sh_offset;
5045               dynamic_size = sec->sh_size;
5046
5047               if (dynamic_addr < segment->p_offset
5048                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5049                 warn (_("the .dynamic section is not contained"
5050                         " within the dynamic segment\n"));
5051               else if (dynamic_addr > segment->p_offset)
5052                 warn (_("the .dynamic section is not the first section"
5053                         " in the dynamic segment.\n"));
5054             }
5055
5056           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5057              segment.  Check this after matching against the section headers
5058              so we don't warn on debuginfo file (which have NOBITS .dynamic
5059              sections).  */
5060           if (dynamic_addr + dynamic_size >= current_file_size)
5061             {
5062               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5063               dynamic_addr = dynamic_size = 0;
5064             }
5065           break;
5066
5067         case PT_INTERP:
5068           if (fseek (file, archive_file_offset + (long) segment->p_offset,
5069                      SEEK_SET))
5070             error (_("Unable to find program interpreter name\n"));
5071           else
5072             {
5073               char fmt [32];
5074               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5075
5076               if (ret >= (int) sizeof (fmt) || ret < 0)
5077                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5078
5079               program_interpreter[0] = 0;
5080               if (fscanf (file, fmt, program_interpreter) <= 0)
5081                 error (_("Unable to read program interpreter name\n"));
5082
5083               if (do_segments)
5084                 printf (_("      [Requesting program interpreter: %s]\n"),
5085                     program_interpreter);
5086             }
5087           break;
5088         }
5089     }
5090
5091   if (do_segments && section_headers != NULL && string_table != NULL)
5092     {
5093       printf (_("\n Section to Segment mapping:\n"));
5094       printf (_("  Segment Sections...\n"));
5095
5096       for (i = 0; i < elf_header.e_phnum; i++)
5097         {
5098           unsigned int j;
5099           Elf_Internal_Shdr * section;
5100
5101           segment = program_headers + i;
5102           section = section_headers + 1;
5103
5104           printf ("   %2.2d     ", i);
5105
5106           for (j = 1; j < elf_header.e_shnum; j++, section++)
5107             {
5108               if (!ELF_TBSS_SPECIAL (section, segment)
5109                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5110                 printf ("%s ", printable_section_name (section));
5111             }
5112
5113           putc ('\n',stdout);
5114         }
5115     }
5116
5117   return TRUE;
5118 }
5119
5120
5121 /* Find the file offset corresponding to VMA by using the program headers.  */
5122
5123 static long
5124 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5125 {
5126   Elf_Internal_Phdr * seg;
5127
5128   if (! get_program_headers (file))
5129     {
5130       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5131       return (long) vma;
5132     }
5133
5134   for (seg = program_headers;
5135        seg < program_headers + elf_header.e_phnum;
5136        ++seg)
5137     {
5138       if (seg->p_type != PT_LOAD)
5139         continue;
5140
5141       if (vma >= (seg->p_vaddr & -seg->p_align)
5142           && vma + size <= seg->p_vaddr + seg->p_filesz)
5143         return vma - seg->p_vaddr + seg->p_offset;
5144     }
5145
5146   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5147         (unsigned long) vma);
5148   return (long) vma;
5149 }
5150
5151
5152 /* Allocate memory and load the sections headers into the global pointer
5153    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
5154    generate any error messages if the load fails.  */
5155
5156 static bfd_boolean
5157 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5158 {
5159   Elf32_External_Shdr * shdrs;
5160   Elf_Internal_Shdr *   internal;
5161   unsigned int i;
5162   unsigned int size = elf_header.e_shentsize;
5163   unsigned int num = probe ? 1 : elf_header.e_shnum;
5164
5165   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5166   if (size == 0 || num == 0)
5167     return FALSE;
5168   if (size < sizeof * shdrs)
5169     {
5170       if (! probe)
5171         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5172       return FALSE;
5173     }
5174   if (!probe && size > sizeof * shdrs)
5175     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5176
5177   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5178                                             size, num,
5179                                             probe ? NULL : _("section headers"));
5180   if (shdrs == NULL)
5181     return FALSE;
5182
5183   if (section_headers != NULL)
5184     free (section_headers);
5185   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5186                                                    sizeof (Elf_Internal_Shdr));
5187   if (section_headers == NULL)
5188     {
5189       if (!probe)
5190         error (_("Out of memory reading %u section headers\n"), num);
5191       return FALSE;
5192     }
5193
5194   for (i = 0, internal = section_headers;
5195        i < num;
5196        i++, internal++)
5197     {
5198       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5199       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5200       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5201       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5202       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5203       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5204       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5205       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5206       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5207       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5208       if (!probe && internal->sh_link > num)
5209         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5210       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5211         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5212     }
5213
5214   free (shdrs);
5215   return TRUE;
5216 }
5217
5218 static bfd_boolean
5219 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5220 {
5221   Elf64_External_Shdr * shdrs;
5222   Elf_Internal_Shdr *   internal;
5223   unsigned int i;
5224   unsigned int size = elf_header.e_shentsize;
5225   unsigned int num = probe ? 1 : elf_header.e_shnum;
5226
5227   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5228   if (size == 0 || num == 0)
5229     return FALSE;
5230   if (size < sizeof * shdrs)
5231     {
5232       if (! probe)
5233         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5234       return FALSE;
5235     }
5236   if (! probe && size > sizeof * shdrs)
5237     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5238
5239   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5240                                             size, num,
5241                                             probe ? NULL : _("section headers"));
5242   if (shdrs == NULL)
5243     return FALSE;
5244
5245   if (section_headers != NULL)
5246     free (section_headers);
5247   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5248                                                    sizeof (Elf_Internal_Shdr));
5249   if (section_headers == NULL)
5250     {
5251       if (! probe)
5252         error (_("Out of memory reading %u section headers\n"), num);
5253       return FALSE;
5254     }
5255
5256   for (i = 0, internal = section_headers;
5257        i < num;
5258        i++, internal++)
5259     {
5260       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5261       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5262       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5263       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5264       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5265       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5266       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5267       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5268       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5269       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5270       if (!probe && internal->sh_link > num)
5271         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5272       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5273         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5274     }
5275
5276   free (shdrs);
5277   return TRUE;
5278 }
5279
5280 static Elf_Internal_Sym *
5281 get_32bit_elf_symbols (FILE * file,
5282                        Elf_Internal_Shdr * section,
5283                        unsigned long * num_syms_return)
5284 {
5285   unsigned long number = 0;
5286   Elf32_External_Sym * esyms = NULL;
5287   Elf_External_Sym_Shndx * shndx = NULL;
5288   Elf_Internal_Sym * isyms = NULL;
5289   Elf_Internal_Sym * psym;
5290   unsigned int j;
5291
5292   if (section->sh_size == 0)
5293     {
5294       if (num_syms_return != NULL)
5295         * num_syms_return = 0;
5296       return NULL;
5297     }
5298
5299   /* Run some sanity checks first.  */
5300   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5301     {
5302       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5303              printable_section_name (section), (unsigned long) section->sh_entsize);
5304       goto exit_point;
5305     }
5306
5307   if (section->sh_size > current_file_size)
5308     {
5309       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5310              printable_section_name (section), (unsigned long) section->sh_size);
5311       goto exit_point;
5312     }
5313
5314   number = section->sh_size / section->sh_entsize;
5315
5316   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5317     {
5318       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5319              (unsigned long) section->sh_size,
5320              printable_section_name (section),
5321              (unsigned long) section->sh_entsize);
5322       goto exit_point;
5323     }
5324
5325   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5326                                            section->sh_size, _("symbols"));
5327   if (esyms == NULL)
5328     goto exit_point;
5329
5330   {
5331     elf_section_list * entry;
5332
5333     shndx = NULL;
5334     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5335       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5336         {
5337           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5338                                                        entry->hdr->sh_offset,
5339                                                        1, entry->hdr->sh_size,
5340                                                        _("symbol table section indicies"));
5341           if (shndx == NULL)
5342             goto exit_point;
5343           /* PR17531: file: heap-buffer-overflow */
5344           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5345             {
5346               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5347                      printable_section_name (entry->hdr),
5348                      (unsigned long) entry->hdr->sh_size,
5349                      (unsigned long) section->sh_size);
5350               goto exit_point;
5351             }
5352         }
5353   }
5354
5355   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5356
5357   if (isyms == NULL)
5358     {
5359       error (_("Out of memory reading %lu symbols\n"),
5360              (unsigned long) number);
5361       goto exit_point;
5362     }
5363
5364   for (j = 0, psym = isyms; j < number; j++, psym++)
5365     {
5366       psym->st_name  = BYTE_GET (esyms[j].st_name);
5367       psym->st_value = BYTE_GET (esyms[j].st_value);
5368       psym->st_size  = BYTE_GET (esyms[j].st_size);
5369       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5370       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5371         psym->st_shndx
5372           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5373       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5374         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5375       psym->st_info  = BYTE_GET (esyms[j].st_info);
5376       psym->st_other = BYTE_GET (esyms[j].st_other);
5377     }
5378
5379  exit_point:
5380   if (shndx != NULL)
5381     free (shndx);
5382   if (esyms != NULL)
5383     free (esyms);
5384
5385   if (num_syms_return != NULL)
5386     * num_syms_return = isyms == NULL ? 0 : number;
5387
5388   return isyms;
5389 }
5390
5391 static Elf_Internal_Sym *
5392 get_64bit_elf_symbols (FILE * file,
5393                        Elf_Internal_Shdr * section,
5394                        unsigned long * num_syms_return)
5395 {
5396   unsigned long number = 0;
5397   Elf64_External_Sym * esyms = NULL;
5398   Elf_External_Sym_Shndx * shndx = NULL;
5399   Elf_Internal_Sym * isyms = NULL;
5400   Elf_Internal_Sym * psym;
5401   unsigned int j;
5402
5403   if (section->sh_size == 0)
5404     {
5405       if (num_syms_return != NULL)
5406         * num_syms_return = 0;
5407       return NULL;
5408     }
5409
5410   /* Run some sanity checks first.  */
5411   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5412     {
5413       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5414              printable_section_name (section),
5415              (unsigned long) section->sh_entsize);
5416       goto exit_point;
5417     }
5418
5419   if (section->sh_size > current_file_size)
5420     {
5421       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5422              printable_section_name (section),
5423              (unsigned long) section->sh_size);
5424       goto exit_point;
5425     }
5426
5427   number = section->sh_size / section->sh_entsize;
5428
5429   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5430     {
5431       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5432              (unsigned long) section->sh_size,
5433              printable_section_name (section),
5434              (unsigned long) section->sh_entsize);
5435       goto exit_point;
5436     }
5437
5438   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5439                                            section->sh_size, _("symbols"));
5440   if (!esyms)
5441     goto exit_point;
5442
5443   {
5444     elf_section_list * entry;
5445
5446     shndx = NULL;
5447     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5448       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5449         {
5450           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5451                                                        entry->hdr->sh_offset,
5452                                                        1, entry->hdr->sh_size,
5453                                                        _("symbol table section indicies"));
5454           if (shndx == NULL)
5455             goto exit_point;
5456           /* PR17531: file: heap-buffer-overflow */
5457           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5458             {
5459               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5460                      printable_section_name (entry->hdr),
5461                      (unsigned long) entry->hdr->sh_size,
5462                      (unsigned long) section->sh_size);
5463               goto exit_point;
5464             }
5465         }
5466   }
5467
5468   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5469
5470   if (isyms == NULL)
5471     {
5472       error (_("Out of memory reading %lu symbols\n"),
5473              (unsigned long) number);
5474       goto exit_point;
5475     }
5476
5477   for (j = 0, psym = isyms; j < number; j++, psym++)
5478     {
5479       psym->st_name  = BYTE_GET (esyms[j].st_name);
5480       psym->st_info  = BYTE_GET (esyms[j].st_info);
5481       psym->st_other = BYTE_GET (esyms[j].st_other);
5482       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5483
5484       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5485         psym->st_shndx
5486           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5487       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5488         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5489
5490       psym->st_value = BYTE_GET (esyms[j].st_value);
5491       psym->st_size  = BYTE_GET (esyms[j].st_size);
5492     }
5493
5494  exit_point:
5495   if (shndx != NULL)
5496     free (shndx);
5497   if (esyms != NULL)
5498     free (esyms);
5499
5500   if (num_syms_return != NULL)
5501     * num_syms_return = isyms == NULL ? 0 : number;
5502
5503   return isyms;
5504 }
5505
5506 static const char *
5507 get_elf_section_flags (bfd_vma sh_flags)
5508 {
5509   static char buff[1024];
5510   char * p = buff;
5511   unsigned int field_size = is_32bit_elf ? 8 : 16;
5512   signed int sindex;
5513   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5514   bfd_vma os_flags = 0;
5515   bfd_vma proc_flags = 0;
5516   bfd_vma unknown_flags = 0;
5517   static const struct
5518     {
5519       const char * str;
5520       unsigned int len;
5521     }
5522   flags [] =
5523     {
5524       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5525       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5526       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5527       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5528       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5529       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5530       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5531       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5532       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5533       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5534       /* IA-64 specific.  */
5535       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5536       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5537       /* IA-64 OpenVMS specific.  */
5538       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5539       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5540       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5541       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5542       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5543       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5544       /* Generic.  */
5545       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5546       /* SPARC specific.  */
5547       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5548       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5549       /* ARM specific.  */
5550       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5551       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5552       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5553       /* GNU specific.  */
5554       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5555     };
5556
5557   if (do_section_details)
5558     {
5559       sprintf (buff, "[%*.*lx]: ",
5560                field_size, field_size, (unsigned long) sh_flags);
5561       p += field_size + 4;
5562     }
5563
5564   while (sh_flags)
5565     {
5566       bfd_vma flag;
5567
5568       flag = sh_flags & - sh_flags;
5569       sh_flags &= ~ flag;
5570
5571       if (do_section_details)
5572         {
5573           switch (flag)
5574             {
5575             case SHF_WRITE:             sindex = 0; break;
5576             case SHF_ALLOC:             sindex = 1; break;
5577             case SHF_EXECINSTR:         sindex = 2; break;
5578             case SHF_MERGE:             sindex = 3; break;
5579             case SHF_STRINGS:           sindex = 4; break;
5580             case SHF_INFO_LINK:         sindex = 5; break;
5581             case SHF_LINK_ORDER:        sindex = 6; break;
5582             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5583             case SHF_GROUP:             sindex = 8; break;
5584             case SHF_TLS:               sindex = 9; break;
5585             case SHF_EXCLUDE:           sindex = 18; break;
5586             case SHF_COMPRESSED:        sindex = 20; break;
5587             case SHF_GNU_MBIND:         sindex = 24; break;
5588
5589             default:
5590               sindex = -1;
5591               switch (elf_header.e_machine)
5592                 {
5593                 case EM_IA_64:
5594                   if (flag == SHF_IA_64_SHORT)
5595                     sindex = 10;
5596                   else if (flag == SHF_IA_64_NORECOV)
5597                     sindex = 11;
5598 #ifdef BFD64
5599                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5600                     switch (flag)
5601                       {
5602                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5603                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5604                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5605                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5606                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5607                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5608                       default:                        break;
5609                       }
5610 #endif
5611                   break;
5612
5613                 case EM_386:
5614                 case EM_IAMCU:
5615                 case EM_X86_64:
5616                 case EM_L1OM:
5617                 case EM_K1OM:
5618                 case EM_OLD_SPARCV9:
5619                 case EM_SPARC32PLUS:
5620                 case EM_SPARCV9:
5621                 case EM_SPARC:
5622                   if (flag == SHF_ORDERED)
5623                     sindex = 19;
5624                   break;
5625
5626                 case EM_ARM:
5627                   switch (flag)
5628                     {
5629                     case SHF_ENTRYSECT: sindex = 21; break;
5630                     case SHF_ARM_PURECODE: sindex = 22; break;
5631                     case SHF_COMDEF: sindex = 23; break;
5632                     default: break;
5633                     }
5634                   break;
5635
5636                 default:
5637                   break;
5638                 }
5639             }
5640
5641           if (sindex != -1)
5642             {
5643               if (p != buff + field_size + 4)
5644                 {
5645                   if (size < (10 + 2))
5646                     {
5647                       warn (_("Internal error: not enough buffer room for section flag info"));
5648                       return _("<unknown>");
5649                     }
5650                   size -= 2;
5651                   *p++ = ',';
5652                   *p++ = ' ';
5653                 }
5654
5655               size -= flags [sindex].len;
5656               p = stpcpy (p, flags [sindex].str);
5657             }
5658           else if (flag & SHF_MASKOS)
5659             os_flags |= flag;
5660           else if (flag & SHF_MASKPROC)
5661             proc_flags |= flag;
5662           else
5663             unknown_flags |= flag;
5664         }
5665       else
5666         {
5667           switch (flag)
5668             {
5669             case SHF_WRITE:             *p = 'W'; break;
5670             case SHF_ALLOC:             *p = 'A'; break;
5671             case SHF_EXECINSTR:         *p = 'X'; break;
5672             case SHF_MERGE:             *p = 'M'; break;
5673             case SHF_STRINGS:           *p = 'S'; break;
5674             case SHF_INFO_LINK:         *p = 'I'; break;
5675             case SHF_LINK_ORDER:        *p = 'L'; break;
5676             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5677             case SHF_GROUP:             *p = 'G'; break;
5678             case SHF_TLS:               *p = 'T'; break;
5679             case SHF_EXCLUDE:           *p = 'E'; break;
5680             case SHF_COMPRESSED:        *p = 'C'; break;
5681             case SHF_GNU_MBIND:         *p = 'D'; break;
5682
5683             default:
5684               if ((elf_header.e_machine == EM_X86_64
5685                    || elf_header.e_machine == EM_L1OM
5686                    || elf_header.e_machine == EM_K1OM)
5687                   && flag == SHF_X86_64_LARGE)
5688                 *p = 'l';
5689               else if (elf_header.e_machine == EM_ARM
5690                        && flag == SHF_ARM_PURECODE)
5691                   *p = 'y';
5692               else if (flag & SHF_MASKOS)
5693                 {
5694                   *p = 'o';
5695                   sh_flags &= ~ SHF_MASKOS;
5696                 }
5697               else if (flag & SHF_MASKPROC)
5698                 {
5699                   *p = 'p';
5700                   sh_flags &= ~ SHF_MASKPROC;
5701                 }
5702               else
5703                 *p = 'x';
5704               break;
5705             }
5706           p++;
5707         }
5708     }
5709
5710   if (do_section_details)
5711     {
5712       if (os_flags)
5713         {
5714           size -= 5 + field_size;
5715           if (p != buff + field_size + 4)
5716             {
5717               if (size < (2 + 1))
5718                 {
5719                   warn (_("Internal error: not enough buffer room for section flag info"));
5720                   return _("<unknown>");
5721                 }
5722               size -= 2;
5723               *p++ = ',';
5724               *p++ = ' ';
5725             }
5726           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5727                    (unsigned long) os_flags);
5728           p += 5 + field_size;
5729         }
5730       if (proc_flags)
5731         {
5732           size -= 7 + field_size;
5733           if (p != buff + field_size + 4)
5734             {
5735               if (size < (2 + 1))
5736                 {
5737                   warn (_("Internal error: not enough buffer room for section flag info"));
5738                   return _("<unknown>");
5739                 }
5740               size -= 2;
5741               *p++ = ',';
5742               *p++ = ' ';
5743             }
5744           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5745                    (unsigned long) proc_flags);
5746           p += 7 + field_size;
5747         }
5748       if (unknown_flags)
5749         {
5750           size -= 10 + field_size;
5751           if (p != buff + field_size + 4)
5752             {
5753               if (size < (2 + 1))
5754                 {
5755                   warn (_("Internal error: not enough buffer room for section flag info"));
5756                   return _("<unknown>");
5757                 }
5758               size -= 2;
5759               *p++ = ',';
5760               *p++ = ' ';
5761             }
5762           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5763                    (unsigned long) unknown_flags);
5764           p += 10 + field_size;
5765         }
5766     }
5767
5768   *p = '\0';
5769   return buff;
5770 }
5771
5772 static unsigned int
5773 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5774 {
5775   if (is_32bit_elf)
5776     {
5777       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5778
5779       if (size < sizeof (* echdr))
5780         {
5781           error (_("Compressed section is too small even for a compression header\n"));
5782           return 0;
5783         }
5784
5785       chdr->ch_type = BYTE_GET (echdr->ch_type);
5786       chdr->ch_size = BYTE_GET (echdr->ch_size);
5787       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5788       return sizeof (*echdr);
5789     }
5790   else
5791     {
5792       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5793
5794       if (size < sizeof (* echdr))
5795         {
5796           error (_("Compressed section is too small even for a compression header\n"));
5797           return 0;
5798         }
5799
5800       chdr->ch_type = BYTE_GET (echdr->ch_type);
5801       chdr->ch_size = BYTE_GET (echdr->ch_size);
5802       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5803       return sizeof (*echdr);
5804     }
5805 }
5806
5807 static bfd_boolean
5808 process_section_headers (FILE * file)
5809 {
5810   Elf_Internal_Shdr * section;
5811   unsigned int i;
5812
5813   section_headers = NULL;
5814
5815   if (elf_header.e_shnum == 0)
5816     {
5817       /* PR binutils/12467.  */
5818       if (elf_header.e_shoff != 0)
5819         {
5820           warn (_("possibly corrupt ELF file header - it has a non-zero"
5821                   " section header offset, but no section headers\n"));
5822           return FALSE;
5823         }
5824       else if (do_sections)
5825         printf (_("\nThere are no sections in this file.\n"));
5826
5827       return TRUE;
5828     }
5829
5830   if (do_sections && !do_header)
5831     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5832             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5833
5834   if (is_32bit_elf)
5835     {
5836       if (! get_32bit_section_headers (file, FALSE))
5837         return FALSE;
5838     }
5839   else
5840     {
5841       if (! get_64bit_section_headers (file, FALSE))
5842         return FALSE;
5843     }
5844
5845   /* Read in the string table, so that we have names to display.  */
5846   if (elf_header.e_shstrndx != SHN_UNDEF
5847        && elf_header.e_shstrndx < elf_header.e_shnum)
5848     {
5849       section = section_headers + elf_header.e_shstrndx;
5850
5851       if (section->sh_size != 0)
5852         {
5853           string_table = (char *) get_data (NULL, file, section->sh_offset,
5854                                             1, section->sh_size,
5855                                             _("string table"));
5856
5857           string_table_length = string_table != NULL ? section->sh_size : 0;
5858         }
5859     }
5860
5861   /* Scan the sections for the dynamic symbol table
5862      and dynamic string table and debug sections.  */
5863   dynamic_symbols = NULL;
5864   dynamic_strings = NULL;
5865   dynamic_syminfo = NULL;
5866   symtab_shndx_list = NULL;
5867
5868   eh_addr_size = is_32bit_elf ? 4 : 8;
5869   switch (elf_header.e_machine)
5870     {
5871     case EM_MIPS:
5872     case EM_MIPS_RS3_LE:
5873       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5874          FDE addresses.  However, the ABI also has a semi-official ILP32
5875          variant for which the normal FDE address size rules apply.
5876
5877          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5878          section, where XX is the size of longs in bits.  Unfortunately,
5879          earlier compilers provided no way of distinguishing ILP32 objects
5880          from LP64 objects, so if there's any doubt, we should assume that
5881          the official LP64 form is being used.  */
5882       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5883           && find_section (".gcc_compiled_long32") == NULL)
5884         eh_addr_size = 8;
5885       break;
5886
5887     case EM_H8_300:
5888     case EM_H8_300H:
5889       switch (elf_header.e_flags & EF_H8_MACH)
5890         {
5891         case E_H8_MACH_H8300:
5892         case E_H8_MACH_H8300HN:
5893         case E_H8_MACH_H8300SN:
5894         case E_H8_MACH_H8300SXN:
5895           eh_addr_size = 2;
5896           break;
5897         case E_H8_MACH_H8300H:
5898         case E_H8_MACH_H8300S:
5899         case E_H8_MACH_H8300SX:
5900           eh_addr_size = 4;
5901           break;
5902         }
5903       break;
5904
5905     case EM_M32C_OLD:
5906     case EM_M32C:
5907       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5908         {
5909         case EF_M32C_CPU_M16C:
5910           eh_addr_size = 2;
5911           break;
5912         }
5913       break;
5914     }
5915
5916 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5917   do                                                                    \
5918     {                                                                   \
5919       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5920       if (section->sh_entsize != expected_entsize)                      \
5921         {                                                               \
5922           char buf[40];                                                 \
5923           sprintf_vma (buf, section->sh_entsize);                       \
5924           /* Note: coded this way so that there is a single string for  \
5925              translation.  */ \
5926           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5927           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5928                    (unsigned) expected_entsize);                        \
5929           section->sh_entsize = expected_entsize;                       \
5930         }                                                               \
5931     }                                                                   \
5932   while (0)
5933
5934 #define CHECK_ENTSIZE(section, i, type)                                 \
5935   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5936                         sizeof (Elf64_External_##type))
5937
5938   for (i = 0, section = section_headers;
5939        i < elf_header.e_shnum;
5940        i++, section++)
5941     {
5942       char * name = SECTION_NAME (section);
5943
5944       if (section->sh_type == SHT_DYNSYM)
5945         {
5946           if (dynamic_symbols != NULL)
5947             {
5948               error (_("File contains multiple dynamic symbol tables\n"));
5949               continue;
5950             }
5951
5952           CHECK_ENTSIZE (section, i, Sym);
5953           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5954         }
5955       else if (section->sh_type == SHT_STRTAB
5956                && streq (name, ".dynstr"))
5957         {
5958           if (dynamic_strings != NULL)
5959             {
5960               error (_("File contains multiple dynamic string tables\n"));
5961               continue;
5962             }
5963
5964           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5965                                                1, section->sh_size,
5966                                                _("dynamic strings"));
5967           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5968         }
5969       else if (section->sh_type == SHT_SYMTAB_SHNDX)
5970         {
5971           elf_section_list * entry = xmalloc (sizeof * entry);
5972           entry->hdr = section;
5973           entry->next = symtab_shndx_list;
5974           symtab_shndx_list = entry;
5975         }
5976       else if (section->sh_type == SHT_SYMTAB)
5977         CHECK_ENTSIZE (section, i, Sym);
5978       else if (section->sh_type == SHT_GROUP)
5979         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5980       else if (section->sh_type == SHT_REL)
5981         CHECK_ENTSIZE (section, i, Rel);
5982       else if (section->sh_type == SHT_RELA)
5983         CHECK_ENTSIZE (section, i, Rela);
5984       else if ((do_debugging || do_debug_info || do_debug_abbrevs
5985                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5986                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5987                 || do_debug_str || do_debug_loc || do_debug_ranges
5988                 || do_debug_addr || do_debug_cu_index)
5989                && (const_strneq (name, ".debug_")
5990                    || const_strneq (name, ".zdebug_")))
5991         {
5992           if (name[1] == 'z')
5993             name += sizeof (".zdebug_") - 1;
5994           else
5995             name += sizeof (".debug_") - 1;
5996
5997           if (do_debugging
5998               || (do_debug_info     && const_strneq (name, "info"))
5999               || (do_debug_info     && const_strneq (name, "types"))
6000               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6001               || (do_debug_lines    && strcmp (name, "line") == 0)
6002               || (do_debug_lines    && const_strneq (name, "line."))
6003               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6004               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6005               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6006               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6007               || (do_debug_aranges  && const_strneq (name, "aranges"))
6008               || (do_debug_ranges   && const_strneq (name, "ranges"))
6009               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6010               || (do_debug_frames   && const_strneq (name, "frame"))
6011               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6012               || (do_debug_macinfo  && const_strneq (name, "macro"))
6013               || (do_debug_str      && const_strneq (name, "str"))
6014               || (do_debug_loc      && const_strneq (name, "loc"))
6015               || (do_debug_loc      && const_strneq (name, "loclists"))
6016               || (do_debug_addr     && const_strneq (name, "addr"))
6017               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6018               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6019               )
6020             request_dump_bynumber (i, DEBUG_DUMP);
6021         }
6022       /* Linkonce section to be combined with .debug_info at link time.  */
6023       else if ((do_debugging || do_debug_info)
6024                && const_strneq (name, ".gnu.linkonce.wi."))
6025         request_dump_bynumber (i, DEBUG_DUMP);
6026       else if (do_debug_frames && streq (name, ".eh_frame"))
6027         request_dump_bynumber (i, DEBUG_DUMP);
6028       else if (do_gdb_index && streq (name, ".gdb_index"))
6029         request_dump_bynumber (i, DEBUG_DUMP);
6030       /* Trace sections for Itanium VMS.  */
6031       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6032                 || do_trace_aranges)
6033                && const_strneq (name, ".trace_"))
6034         {
6035           name += sizeof (".trace_") - 1;
6036
6037           if (do_debugging
6038               || (do_trace_info     && streq (name, "info"))
6039               || (do_trace_abbrevs  && streq (name, "abbrev"))
6040               || (do_trace_aranges  && streq (name, "aranges"))
6041               )
6042             request_dump_bynumber (i, DEBUG_DUMP);
6043         }
6044     }
6045
6046   if (! do_sections)
6047     return TRUE;
6048
6049   if (elf_header.e_shnum > 1)
6050     printf (_("\nSection Headers:\n"));
6051   else
6052     printf (_("\nSection Header:\n"));
6053
6054   if (is_32bit_elf)
6055     {
6056       if (do_section_details)
6057         {
6058           printf (_("  [Nr] Name\n"));
6059           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6060         }
6061       else
6062         printf
6063           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6064     }
6065   else if (do_wide)
6066     {
6067       if (do_section_details)
6068         {
6069           printf (_("  [Nr] Name\n"));
6070           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6071         }
6072       else
6073         printf
6074           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6075     }
6076   else
6077     {
6078       if (do_section_details)
6079         {
6080           printf (_("  [Nr] Name\n"));
6081           printf (_("       Type              Address          Offset            Link\n"));
6082           printf (_("       Size              EntSize          Info              Align\n"));
6083         }
6084       else
6085         {
6086           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6087           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6088         }
6089     }
6090
6091   if (do_section_details)
6092     printf (_("       Flags\n"));
6093
6094   for (i = 0, section = section_headers;
6095        i < elf_header.e_shnum;
6096        i++, section++)
6097     {
6098       /* Run some sanity checks on the section header.  */
6099
6100       /* Check the sh_link field.  */
6101       switch (section->sh_type)
6102         {
6103         case SHT_SYMTAB_SHNDX:
6104         case SHT_GROUP:
6105         case SHT_HASH:
6106         case SHT_GNU_HASH:
6107         case SHT_GNU_versym:
6108         case SHT_REL:
6109         case SHT_RELA:
6110           if (section->sh_link < 1
6111               || section->sh_link >= elf_header.e_shnum
6112               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6113                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6114             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6115                   i, section->sh_link);
6116           break;
6117
6118         case SHT_DYNAMIC:
6119         case SHT_SYMTAB:
6120         case SHT_DYNSYM:
6121         case SHT_GNU_verneed:
6122         case SHT_GNU_verdef:
6123         case SHT_GNU_LIBLIST:
6124           if (section->sh_link < 1
6125               || section->sh_link >= elf_header.e_shnum
6126               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6127             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6128                   i, section->sh_link);
6129           break;
6130
6131         case SHT_INIT_ARRAY:
6132         case SHT_FINI_ARRAY:
6133         case SHT_PREINIT_ARRAY:
6134           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6135             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6136                   i, section->sh_link);
6137           break;
6138
6139         default:
6140           /* FIXME: Add support for target specific section types.  */
6141 #if 0     /* Currently we do not check other section types as there are too
6142              many special cases.  Stab sections for example have a type
6143              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6144              section.  */
6145           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6146             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6147                   i, section->sh_link);
6148 #endif
6149           break;
6150         }
6151
6152       /* Check the sh_info field.  */
6153       switch (section->sh_type)
6154         {
6155         case SHT_REL:
6156         case SHT_RELA:
6157           if (section->sh_info < 1
6158               || section->sh_info >= elf_header.e_shnum
6159               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6160                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6161                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6162                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6163                   /* FIXME: Are other section types valid ?  */
6164                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6165             {
6166               if (section->sh_info == 0
6167                   && (streq (SECTION_NAME (section), ".rel.dyn")
6168                       || streq (SECTION_NAME (section), ".rela.dyn")))
6169                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6170                    of zero.  The relocations in these sections may apply
6171                    to many different sections.  */
6172                    ;
6173               else
6174                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6175                       i, section->sh_info);
6176             }
6177           break;
6178
6179         case SHT_DYNAMIC:
6180         case SHT_HASH:
6181         case SHT_SYMTAB_SHNDX:
6182         case SHT_INIT_ARRAY:
6183         case SHT_FINI_ARRAY:
6184         case SHT_PREINIT_ARRAY:
6185           if (section->sh_info != 0)
6186             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6187                   i, section->sh_info);
6188           break;
6189
6190         case SHT_GROUP:
6191         case SHT_SYMTAB:
6192         case SHT_DYNSYM:
6193           /* A symbol index - we assume that it is valid.  */
6194           break;
6195
6196         default:
6197           /* FIXME: Add support for target specific section types.  */
6198           if (section->sh_type == SHT_NOBITS)
6199             /* NOBITS section headers with non-zero sh_info fields can be
6200                created when a binary is stripped of everything but its debug
6201                information.  The stripped sections have their headers
6202                preserved but their types set to SHT_NOBITS.  So do not check
6203                this type of section.  */
6204             ;
6205           else if (section->sh_flags & SHF_INFO_LINK)
6206             {
6207               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6208                 warn (_("[%2u]: Expected link to another section in info field"), i);
6209             }
6210           else if (section->sh_type < SHT_LOOS
6211                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6212                    && section->sh_info != 0)
6213             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6214                   i, section->sh_info);
6215           break;
6216         }
6217
6218       printf ("  [%2u] ", i);
6219       if (do_section_details)
6220         printf ("%s\n      ", printable_section_name (section));
6221       else
6222         print_symbol (-17, SECTION_NAME (section));
6223
6224       printf (do_wide ? " %-15s " : " %-15.15s ",
6225               get_section_type_name (section->sh_type));
6226
6227       if (is_32bit_elf)
6228         {
6229           const char * link_too_big = NULL;
6230
6231           print_vma (section->sh_addr, LONG_HEX);
6232
6233           printf ( " %6.6lx %6.6lx %2.2lx",
6234                    (unsigned long) section->sh_offset,
6235                    (unsigned long) section->sh_size,
6236                    (unsigned long) section->sh_entsize);
6237
6238           if (do_section_details)
6239             fputs ("  ", stdout);
6240           else
6241             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6242
6243           if (section->sh_link >= elf_header.e_shnum)
6244             {
6245               link_too_big = "";
6246               /* The sh_link value is out of range.  Normally this indicates
6247                  an error but it can have special values in Solaris binaries.  */
6248               switch (elf_header.e_machine)
6249                 {
6250                 case EM_386:
6251                 case EM_IAMCU:
6252                 case EM_X86_64:
6253                 case EM_L1OM:
6254                 case EM_K1OM:
6255                 case EM_OLD_SPARCV9:
6256                 case EM_SPARC32PLUS:
6257                 case EM_SPARCV9:
6258                 case EM_SPARC:
6259                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6260                     link_too_big = "BEFORE";
6261                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6262                     link_too_big = "AFTER";
6263                   break;
6264                 default:
6265                   break;
6266                 }
6267             }
6268
6269           if (do_section_details)
6270             {
6271               if (link_too_big != NULL && * link_too_big)
6272                 printf ("<%s> ", link_too_big);
6273               else
6274                 printf ("%2u ", section->sh_link);
6275               printf ("%3u %2lu\n", section->sh_info,
6276                       (unsigned long) section->sh_addralign);
6277             }
6278           else
6279             printf ("%2u %3u %2lu\n",
6280                     section->sh_link,
6281                     section->sh_info,
6282                     (unsigned long) section->sh_addralign);
6283
6284           if (link_too_big && ! * link_too_big)
6285             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6286                   i, section->sh_link);
6287         }
6288       else if (do_wide)
6289         {
6290           print_vma (section->sh_addr, LONG_HEX);
6291
6292           if ((long) section->sh_offset == section->sh_offset)
6293             printf (" %6.6lx", (unsigned long) section->sh_offset);
6294           else
6295             {
6296               putchar (' ');
6297               print_vma (section->sh_offset, LONG_HEX);
6298             }
6299
6300           if ((unsigned long) section->sh_size == section->sh_size)
6301             printf (" %6.6lx", (unsigned long) section->sh_size);
6302           else
6303             {
6304               putchar (' ');
6305               print_vma (section->sh_size, LONG_HEX);
6306             }
6307
6308           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6309             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6310           else
6311             {
6312               putchar (' ');
6313               print_vma (section->sh_entsize, LONG_HEX);
6314             }
6315
6316           if (do_section_details)
6317             fputs ("  ", stdout);
6318           else
6319             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6320
6321           printf ("%2u %3u ", section->sh_link, section->sh_info);
6322
6323           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6324             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6325           else
6326             {
6327               print_vma (section->sh_addralign, DEC);
6328               putchar ('\n');
6329             }
6330         }
6331       else if (do_section_details)
6332         {
6333           printf ("       %-15.15s  ",
6334                   get_section_type_name (section->sh_type));
6335           print_vma (section->sh_addr, LONG_HEX);
6336           if ((long) section->sh_offset == section->sh_offset)
6337             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6338           else
6339             {
6340               printf ("  ");
6341               print_vma (section->sh_offset, LONG_HEX);
6342             }
6343           printf ("  %u\n       ", section->sh_link);
6344           print_vma (section->sh_size, LONG_HEX);
6345           putchar (' ');
6346           print_vma (section->sh_entsize, LONG_HEX);
6347
6348           printf ("  %-16u  %lu\n",
6349                   section->sh_info,
6350                   (unsigned long) section->sh_addralign);
6351         }
6352       else
6353         {
6354           putchar (' ');
6355           print_vma (section->sh_addr, LONG_HEX);
6356           if ((long) section->sh_offset == section->sh_offset)
6357             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6358           else
6359             {
6360               printf ("  ");
6361               print_vma (section->sh_offset, LONG_HEX);
6362             }
6363           printf ("\n       ");
6364           print_vma (section->sh_size, LONG_HEX);
6365           printf ("  ");
6366           print_vma (section->sh_entsize, LONG_HEX);
6367
6368           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6369
6370           printf ("     %2u   %3u     %lu\n",
6371                   section->sh_link,
6372                   section->sh_info,
6373                   (unsigned long) section->sh_addralign);
6374         }
6375
6376       if (do_section_details)
6377         {
6378           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6379           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6380             {
6381               /* Minimum section size is 12 bytes for 32-bit compression
6382                  header + 12 bytes for compressed data header.  */
6383               unsigned char buf[24];
6384
6385               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6386               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6387                             sizeof (buf), _("compression header")))
6388                 {
6389                   Elf_Internal_Chdr chdr;
6390
6391                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6392
6393                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6394                     printf ("       ZLIB, ");
6395                   else
6396                     printf (_("       [<unknown>: 0x%x], "),
6397                             chdr.ch_type);
6398                   print_vma (chdr.ch_size, LONG_HEX);
6399                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6400                 }
6401             }
6402         }
6403     }
6404
6405   if (!do_section_details)
6406     {
6407       /* The ordering of the letters shown here matches the ordering of the
6408          corresponding SHF_xxx values, and hence the order in which these
6409          letters will be displayed to the user.  */
6410       printf (_("Key to Flags:\n\
6411   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6412   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6413   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6414       if (elf_header.e_machine == EM_X86_64
6415           || elf_header.e_machine == EM_L1OM
6416           || elf_header.e_machine == EM_K1OM)
6417         printf (_("l (large), "));
6418       else if (elf_header.e_machine == EM_ARM)
6419         printf (_("y (purecode), "));
6420       printf ("p (processor specific)\n");
6421     }
6422
6423   return TRUE;
6424 }
6425
6426 static const char *
6427 get_group_flags (unsigned int flags)
6428 {
6429   static char buff[128];
6430
6431   if (flags == 0)
6432     return "";
6433   else if (flags == GRP_COMDAT)
6434     return "COMDAT ";
6435
6436   snprintf (buff, 14, _("[0x%x: "), flags);
6437
6438   flags &= ~ GRP_COMDAT;
6439   if (flags & GRP_MASKOS)
6440     {
6441       strcat (buff, "<OS specific>");
6442       flags &= ~ GRP_MASKOS;
6443     }
6444
6445   if (flags & GRP_MASKPROC)
6446     {
6447       strcat (buff, "<PROC specific>");
6448       flags &= ~ GRP_MASKPROC;
6449     }
6450
6451   if (flags)
6452     strcat (buff, "<unknown>");
6453
6454   strcat (buff, "]");
6455   return buff;
6456 }
6457
6458 static bfd_boolean
6459 process_section_groups (FILE * file)
6460 {
6461   Elf_Internal_Shdr * section;
6462   unsigned int i;
6463   struct group * group;
6464   Elf_Internal_Shdr * symtab_sec;
6465   Elf_Internal_Shdr * strtab_sec;
6466   Elf_Internal_Sym * symtab;
6467   unsigned long num_syms;
6468   char * strtab;
6469   size_t strtab_size;
6470
6471   /* Don't process section groups unless needed.  */
6472   if (!do_unwind && !do_section_groups)
6473     return TRUE;
6474
6475   if (elf_header.e_shnum == 0)
6476     {
6477       if (do_section_groups)
6478         printf (_("\nThere are no sections to group in this file.\n"));
6479
6480       return TRUE;
6481     }
6482
6483   if (section_headers == NULL)
6484     {
6485       error (_("Section headers are not available!\n"));
6486       /* PR 13622: This can happen with a corrupt ELF header.  */
6487       return FALSE;
6488     }
6489
6490   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6491                                                      sizeof (struct group *));
6492
6493   if (section_headers_groups == NULL)
6494     {
6495       error (_("Out of memory reading %u section group headers\n"),
6496              elf_header.e_shnum);
6497       return FALSE;
6498     }
6499
6500   /* Scan the sections for the group section.  */
6501   group_count = 0;
6502   for (i = 0, section = section_headers;
6503        i < elf_header.e_shnum;
6504        i++, section++)
6505     if (section->sh_type == SHT_GROUP)
6506       group_count++;
6507
6508   if (group_count == 0)
6509     {
6510       if (do_section_groups)
6511         printf (_("\nThere are no section groups in this file.\n"));
6512
6513       return TRUE;
6514     }
6515
6516   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6517
6518   if (section_groups == NULL)
6519     {
6520       error (_("Out of memory reading %lu groups\n"),
6521              (unsigned long) group_count);
6522       return FALSE;
6523     }
6524
6525   symtab_sec = NULL;
6526   strtab_sec = NULL;
6527   symtab = NULL;
6528   num_syms = 0;
6529   strtab = NULL;
6530   strtab_size = 0;
6531   for (i = 0, section = section_headers, group = section_groups;
6532        i < elf_header.e_shnum;
6533        i++, section++)
6534     {
6535       if (section->sh_type == SHT_GROUP)
6536         {
6537           const char * name = printable_section_name (section);
6538           const char * group_name;
6539           unsigned char * start;
6540           unsigned char * indices;
6541           unsigned int entry, j, size;
6542           Elf_Internal_Shdr * sec;
6543           Elf_Internal_Sym * sym;
6544
6545           /* Get the symbol table.  */
6546           if (section->sh_link >= elf_header.e_shnum
6547               || ((sec = section_headers + section->sh_link)->sh_type
6548                   != SHT_SYMTAB))
6549             {
6550               error (_("Bad sh_link in group section `%s'\n"), name);
6551               continue;
6552             }
6553
6554           if (symtab_sec != sec)
6555             {
6556               symtab_sec = sec;
6557               if (symtab)
6558                 free (symtab);
6559               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6560             }
6561
6562           if (symtab == NULL)
6563             {
6564               error (_("Corrupt header in group section `%s'\n"), name);
6565               continue;
6566             }
6567
6568           if (section->sh_info >= num_syms)
6569             {
6570               error (_("Bad sh_info in group section `%s'\n"), name);
6571               continue;
6572             }
6573
6574           sym = symtab + section->sh_info;
6575
6576           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6577             {
6578               if (sym->st_shndx == 0
6579                   || sym->st_shndx >= elf_header.e_shnum)
6580                 {
6581                   error (_("Bad sh_info in group section `%s'\n"), name);
6582                   continue;
6583                 }
6584
6585               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6586               strtab_sec = NULL;
6587               if (strtab)
6588                 free (strtab);
6589               strtab = NULL;
6590               strtab_size = 0;
6591             }
6592           else
6593             {
6594               /* Get the string table.  */
6595               if (symtab_sec->sh_link >= elf_header.e_shnum)
6596                 {
6597                   strtab_sec = NULL;
6598                   if (strtab)
6599                     free (strtab);
6600                   strtab = NULL;
6601                   strtab_size = 0;
6602                 }
6603               else if (strtab_sec
6604                        != (sec = section_headers + symtab_sec->sh_link))
6605                 {
6606                   strtab_sec = sec;
6607                   if (strtab)
6608                     free (strtab);
6609
6610                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6611                                               1, strtab_sec->sh_size,
6612                                               _("string table"));
6613                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6614                 }
6615               group_name = sym->st_name < strtab_size
6616                 ? strtab + sym->st_name : _("<corrupt>");
6617             }
6618
6619           /* PR 17531: file: loop.  */
6620           if (section->sh_entsize > section->sh_size)
6621             {
6622               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6623                      printable_section_name (section),
6624                      (unsigned long) section->sh_entsize,
6625                      (unsigned long) section->sh_size);
6626               break;
6627             }
6628
6629           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6630                                               1, section->sh_size,
6631                                               _("section data"));
6632           if (start == NULL)
6633             continue;
6634
6635           indices = start;
6636           size = (section->sh_size / section->sh_entsize) - 1;
6637           entry = byte_get (indices, 4);
6638           indices += 4;
6639
6640           if (do_section_groups)
6641             {
6642               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6643                       get_group_flags (entry), i, name, group_name, size);
6644
6645               printf (_("   [Index]    Name\n"));
6646             }
6647
6648           group->group_index = i;
6649
6650           for (j = 0; j < size; j++)
6651             {
6652               struct group_list * g;
6653
6654               entry = byte_get (indices, 4);
6655               indices += 4;
6656
6657               if (entry >= elf_header.e_shnum)
6658                 {
6659                   static unsigned num_group_errors = 0;
6660
6661                   if (num_group_errors ++ < 10)
6662                     {
6663                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6664                              entry, i, elf_header.e_shnum - 1);
6665                       if (num_group_errors == 10)
6666                         warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6667                     }
6668                   continue;
6669                 }
6670
6671               if (section_headers_groups [entry] != NULL)
6672                 {
6673                   if (entry)
6674                     {
6675                       static unsigned num_errs = 0;
6676
6677                       if (num_errs ++ < 10)
6678                         {
6679                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6680                                  entry, i,
6681                                  section_headers_groups [entry]->group_index);
6682                           if (num_errs == 10)
6683                             warn (_("Further error messages about already contained group sections suppressed\n"));
6684                         }
6685                       continue;
6686                     }
6687                   else
6688                     {
6689                       /* Intel C/C++ compiler may put section 0 in a
6690                          section group.  We just warn it the first time
6691                          and ignore it afterwards.  */
6692                       static bfd_boolean warned = FALSE;
6693                       if (!warned)
6694                         {
6695                           error (_("section 0 in group section [%5u]\n"),
6696                                  section_headers_groups [entry]->group_index);
6697                           warned = TRUE;
6698                         }
6699                     }
6700                 }
6701
6702               section_headers_groups [entry] = group;
6703
6704               if (do_section_groups)
6705                 {
6706                   sec = section_headers + entry;
6707                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6708                 }
6709
6710               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6711               g->section_index = entry;
6712               g->next = group->root;
6713               group->root = g;
6714             }
6715
6716           if (start)
6717             free (start);
6718
6719           group++;
6720         }
6721     }
6722
6723   if (symtab)
6724     free (symtab);
6725   if (strtab)
6726     free (strtab);
6727   return TRUE;
6728 }
6729
6730 /* Data used to display dynamic fixups.  */
6731
6732 struct ia64_vms_dynfixup
6733 {
6734   bfd_vma needed_ident;         /* Library ident number.  */
6735   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6736   bfd_vma fixup_needed;         /* Index of the library.  */
6737   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6738   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6739 };
6740
6741 /* Data used to display dynamic relocations.  */
6742
6743 struct ia64_vms_dynimgrela
6744 {
6745   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6746   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6747 };
6748
6749 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6750    library).  */
6751
6752 static bfd_boolean
6753 dump_ia64_vms_dynamic_fixups (FILE * file,
6754                               struct ia64_vms_dynfixup * fixup,
6755                               const char * strtab,
6756                               unsigned int strtab_sz)
6757 {
6758   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6759   long i;
6760   const char * lib_name;
6761
6762   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6763                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6764                    _("dynamic section image fixups"));
6765   if (!imfs)
6766     return FALSE;
6767
6768   if (fixup->needed < strtab_sz)
6769     lib_name = strtab + fixup->needed;
6770   else
6771     {
6772       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6773             (unsigned long) fixup->needed);
6774       lib_name = "???";
6775     }
6776   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6777           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6778   printf
6779     (_("Seg Offset           Type                             SymVec DataType\n"));
6780
6781   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6782     {
6783       unsigned int type;
6784       const char *rtype;
6785
6786       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6787       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6788       type = BYTE_GET (imfs [i].type);
6789       rtype = elf_ia64_reloc_type (type);
6790       if (rtype == NULL)
6791         printf (" 0x%08x                       ", type);
6792       else
6793         printf (" %-32s ", rtype);
6794       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6795       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6796     }
6797
6798   free (imfs);
6799   return TRUE;
6800 }
6801
6802 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6803
6804 static bfd_boolean
6805 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6806 {
6807   Elf64_External_VMS_IMAGE_RELA *imrs;
6808   long i;
6809
6810   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6811                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6812                    _("dynamic section image relocations"));
6813   if (!imrs)
6814     return FALSE;
6815
6816   printf (_("\nImage relocs\n"));
6817   printf
6818     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6819
6820   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6821     {
6822       unsigned int type;
6823       const char *rtype;
6824
6825       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6826       printf ("%08" BFD_VMA_FMT "x ",
6827               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6828       type = BYTE_GET (imrs [i].type);
6829       rtype = elf_ia64_reloc_type (type);
6830       if (rtype == NULL)
6831         printf ("0x%08x                      ", type);
6832       else
6833         printf ("%-31s ", rtype);
6834       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6835       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6836       printf ("%08" BFD_VMA_FMT "x\n",
6837               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6838     }
6839
6840   free (imrs);
6841   return TRUE;
6842 }
6843
6844 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6845
6846 static bfd_boolean
6847 process_ia64_vms_dynamic_relocs (FILE *file)
6848 {
6849   struct ia64_vms_dynfixup fixup;
6850   struct ia64_vms_dynimgrela imgrela;
6851   Elf_Internal_Dyn *entry;
6852   bfd_vma strtab_off = 0;
6853   bfd_vma strtab_sz = 0;
6854   char *strtab = NULL;
6855   bfd_boolean res = TRUE;
6856
6857   memset (&fixup, 0, sizeof (fixup));
6858   memset (&imgrela, 0, sizeof (imgrela));
6859
6860   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6861   for (entry = dynamic_section;
6862        entry < dynamic_section + dynamic_nent;
6863        entry++)
6864     {
6865       switch (entry->d_tag)
6866         {
6867         case DT_IA_64_VMS_STRTAB_OFFSET:
6868           strtab_off = entry->d_un.d_val;
6869           break;
6870         case DT_STRSZ:
6871           strtab_sz = entry->d_un.d_val;
6872           if (strtab == NULL)
6873             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6874                                1, strtab_sz, _("dynamic string section"));
6875           break;
6876
6877         case DT_IA_64_VMS_NEEDED_IDENT:
6878           fixup.needed_ident = entry->d_un.d_val;
6879           break;
6880         case DT_NEEDED:
6881           fixup.needed = entry->d_un.d_val;
6882           break;
6883         case DT_IA_64_VMS_FIXUP_NEEDED:
6884           fixup.fixup_needed = entry->d_un.d_val;
6885           break;
6886         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6887           fixup.fixup_rela_cnt = entry->d_un.d_val;
6888           break;
6889         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6890           fixup.fixup_rela_off = entry->d_un.d_val;
6891           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6892             res = FALSE;
6893           break;
6894         case DT_IA_64_VMS_IMG_RELA_CNT:
6895           imgrela.img_rela_cnt = entry->d_un.d_val;
6896           break;
6897         case DT_IA_64_VMS_IMG_RELA_OFF:
6898           imgrela.img_rela_off = entry->d_un.d_val;
6899           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6900             res = FALSE;
6901           break;
6902
6903         default:
6904           break;
6905         }
6906     }
6907
6908   if (strtab != NULL)
6909     free (strtab);
6910
6911   return res;
6912 }
6913
6914 static struct
6915 {
6916   const char * name;
6917   int reloc;
6918   int size;
6919   int rela;
6920 }
6921   dynamic_relocations [] =
6922 {
6923   { "REL", DT_REL, DT_RELSZ, FALSE },
6924   { "RELA", DT_RELA, DT_RELASZ, TRUE },
6925   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6926 };
6927
6928 /* Process the reloc section.  */
6929
6930 static bfd_boolean
6931 process_relocs (FILE * file)
6932 {
6933   unsigned long rel_size;
6934   unsigned long rel_offset;
6935
6936   if (!do_reloc)
6937     return TRUE;
6938
6939   if (do_using_dynamic)
6940     {
6941       int          is_rela;
6942       const char * name;
6943       bfd_boolean  has_dynamic_reloc;
6944       unsigned int i;
6945
6946       has_dynamic_reloc = FALSE;
6947
6948       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6949         {
6950           is_rela = dynamic_relocations [i].rela;
6951           name = dynamic_relocations [i].name;
6952           rel_size = dynamic_info [dynamic_relocations [i].size];
6953           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6954
6955           if (rel_size)
6956             has_dynamic_reloc = TRUE;
6957
6958           if (is_rela == UNKNOWN)
6959             {
6960               if (dynamic_relocations [i].reloc == DT_JMPREL)
6961                 switch (dynamic_info[DT_PLTREL])
6962                   {
6963                   case DT_REL:
6964                     is_rela = FALSE;
6965                     break;
6966                   case DT_RELA:
6967                     is_rela = TRUE;
6968                     break;
6969                   }
6970             }
6971
6972           if (rel_size)
6973             {
6974               printf
6975                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6976                  name, rel_offset, rel_size);
6977
6978               dump_relocations (file,
6979                                 offset_from_vma (file, rel_offset, rel_size),
6980                                 rel_size,
6981                                 dynamic_symbols, num_dynamic_syms,
6982                                 dynamic_strings, dynamic_strings_length,
6983                                 is_rela, TRUE /* is_dynamic */);
6984             }
6985         }
6986
6987       if (is_ia64_vms ())
6988         if (process_ia64_vms_dynamic_relocs (file))
6989           has_dynamic_reloc = TRUE;
6990
6991       if (! has_dynamic_reloc)
6992         printf (_("\nThere are no dynamic relocations in this file.\n"));
6993     }
6994   else
6995     {
6996       Elf_Internal_Shdr * section;
6997       unsigned long i;
6998       bfd_boolean found = FALSE;
6999
7000       for (i = 0, section = section_headers;
7001            i < elf_header.e_shnum;
7002            i++, section++)
7003         {
7004           if (   section->sh_type != SHT_RELA
7005               && section->sh_type != SHT_REL)
7006             continue;
7007
7008           rel_offset = section->sh_offset;
7009           rel_size   = section->sh_size;
7010
7011           if (rel_size)
7012             {
7013               Elf_Internal_Shdr * strsec;
7014               int is_rela;
7015
7016               printf (_("\nRelocation section "));
7017
7018               if (string_table == NULL)
7019                 printf ("%d", section->sh_name);
7020               else
7021                 printf ("'%s'", printable_section_name (section));
7022
7023               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7024                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7025
7026               is_rela = section->sh_type == SHT_RELA;
7027
7028               if (section->sh_link != 0
7029                   && section->sh_link < elf_header.e_shnum)
7030                 {
7031                   Elf_Internal_Shdr * symsec;
7032                   Elf_Internal_Sym *  symtab;
7033                   unsigned long nsyms;
7034                   unsigned long strtablen = 0;
7035                   char * strtab = NULL;
7036
7037                   symsec = section_headers + section->sh_link;
7038                   if (symsec->sh_type != SHT_SYMTAB
7039                       && symsec->sh_type != SHT_DYNSYM)
7040                     continue;
7041
7042                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7043
7044                   if (symtab == NULL)
7045                     continue;
7046
7047                   if (symsec->sh_link != 0
7048                       && symsec->sh_link < elf_header.e_shnum)
7049                     {
7050                       strsec = section_headers + symsec->sh_link;
7051
7052                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7053                                                   1, strsec->sh_size,
7054                                                   _("string table"));
7055                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7056                     }
7057
7058                   dump_relocations (file, rel_offset, rel_size,
7059                                     symtab, nsyms, strtab, strtablen,
7060                                     is_rela,
7061                                     symsec->sh_type == SHT_DYNSYM);
7062                   if (strtab)
7063                     free (strtab);
7064                   free (symtab);
7065                 }
7066               else
7067                 dump_relocations (file, rel_offset, rel_size,
7068                                   NULL, 0, NULL, 0, is_rela,
7069                                   FALSE /* is_dynamic */);
7070
7071               found = TRUE;
7072             }
7073         }
7074
7075       if (! found)
7076         printf (_("\nThere are no relocations in this file.\n"));
7077     }
7078
7079   return TRUE;
7080 }
7081
7082 /* An absolute address consists of a section and an offset.  If the
7083    section is NULL, the offset itself is the address, otherwise, the
7084    address equals to LOAD_ADDRESS(section) + offset.  */
7085
7086 struct absaddr
7087 {
7088   unsigned short section;
7089   bfd_vma offset;
7090 };
7091
7092 #define ABSADDR(a) \
7093   ((a).section \
7094    ? section_headers [(a).section].sh_addr + (a).offset \
7095    : (a).offset)
7096
7097 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7098    name, if found, and the offset from the symbol to ADDR.  */
7099
7100 static void
7101 find_symbol_for_address (Elf_Internal_Sym * symtab,
7102                          unsigned long      nsyms,
7103                          const char *       strtab,
7104                          unsigned long      strtab_size,
7105                          struct absaddr     addr,
7106                          const char **      symname,
7107                          bfd_vma *          offset)
7108 {
7109   bfd_vma dist = 0x100000;
7110   Elf_Internal_Sym * sym;
7111   Elf_Internal_Sym * beg;
7112   Elf_Internal_Sym * end;
7113   Elf_Internal_Sym * best = NULL;
7114
7115   REMOVE_ARCH_BITS (addr.offset);
7116   beg = symtab;
7117   end = symtab + nsyms;
7118
7119   while (beg < end)
7120     {
7121       bfd_vma value;
7122
7123       sym = beg + (end - beg) / 2;
7124
7125       value = sym->st_value;
7126       REMOVE_ARCH_BITS (value);
7127
7128       if (sym->st_name != 0
7129           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7130           && addr.offset >= value
7131           && addr.offset - value < dist)
7132         {
7133           best = sym;
7134           dist = addr.offset - value;
7135           if (!dist)
7136             break;
7137         }
7138
7139       if (addr.offset < value)
7140         end = sym;
7141       else
7142         beg = sym + 1;
7143     }
7144
7145   if (best)
7146     {
7147       *symname = (best->st_name >= strtab_size
7148                   ? _("<corrupt>") : strtab + best->st_name);
7149       *offset = dist;
7150       return;
7151     }
7152
7153   *symname = NULL;
7154   *offset = addr.offset;
7155 }
7156
7157 static /* signed */ int
7158 symcmp (const void *p, const void *q)
7159 {
7160   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7161   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7162
7163   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7164 }
7165
7166 /* Process the unwind section.  */
7167
7168 #include "unwind-ia64.h"
7169
7170 struct ia64_unw_table_entry
7171 {
7172   struct absaddr start;
7173   struct absaddr end;
7174   struct absaddr info;
7175 };
7176
7177 struct ia64_unw_aux_info
7178 {
7179   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7180   unsigned long                 table_len;      /* Length of unwind table.  */
7181   unsigned char *               info;           /* Unwind info.  */
7182   unsigned long                 info_size;      /* Size of unwind info.  */
7183   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7184   bfd_vma                       seg_base;       /* Starting address of segment.  */
7185   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7186   unsigned long                 nsyms;          /* Number of symbols.  */
7187   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7188   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7189   char *                        strtab;         /* The string table.  */
7190   unsigned long                 strtab_size;    /* Size of string table.  */
7191 };
7192
7193 static bfd_boolean
7194 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7195 {
7196   struct ia64_unw_table_entry * tp;
7197   unsigned long j, nfuns;
7198   int in_body;
7199   bfd_boolean res = TRUE;
7200
7201   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7202   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7203     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7204       aux->funtab[nfuns++] = aux->symtab[j];
7205   aux->nfuns = nfuns;
7206   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7207
7208   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7209     {
7210       bfd_vma stamp;
7211       bfd_vma offset;
7212       const unsigned char * dp;
7213       const unsigned char * head;
7214       const unsigned char * end;
7215       const char * procname;
7216
7217       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7218                                aux->strtab_size, tp->start, &procname, &offset);
7219
7220       fputs ("\n<", stdout);
7221
7222       if (procname)
7223         {
7224           fputs (procname, stdout);
7225
7226           if (offset)
7227             printf ("+%lx", (unsigned long) offset);
7228         }
7229
7230       fputs (">: [", stdout);
7231       print_vma (tp->start.offset, PREFIX_HEX);
7232       fputc ('-', stdout);
7233       print_vma (tp->end.offset, PREFIX_HEX);
7234       printf ("], info at +0x%lx\n",
7235               (unsigned long) (tp->info.offset - aux->seg_base));
7236
7237       /* PR 17531: file: 86232b32.  */
7238       if (aux->info == NULL)
7239         continue;
7240
7241       /* PR 17531: file: 0997b4d1.  */
7242       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7243         {
7244           warn (_("Invalid offset %lx in table entry %ld\n"),
7245                 (long) tp->info.offset, (long) (tp - aux->table));
7246           res = FALSE;
7247           continue;
7248         }
7249
7250       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7251       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7252
7253       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7254               (unsigned) UNW_VER (stamp),
7255               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7256               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7257               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7258               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7259
7260       if (UNW_VER (stamp) != 1)
7261         {
7262           printf (_("\tUnknown version.\n"));
7263           continue;
7264         }
7265
7266       in_body = 0;
7267       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7268       /* PR 17531: file: 16ceda89.  */
7269       if (end > aux->info + aux->info_size)
7270         end = aux->info + aux->info_size;
7271       for (dp = head + 8; dp < end;)
7272         dp = unw_decode (dp, in_body, & in_body, end);
7273     }
7274
7275   free (aux->funtab);
7276
7277   return res;
7278 }
7279
7280 static bfd_boolean
7281 slurp_ia64_unwind_table (FILE * file,
7282                          struct ia64_unw_aux_info * aux,
7283                          Elf_Internal_Shdr * sec)
7284 {
7285   unsigned long size, nrelas, i;
7286   Elf_Internal_Phdr * seg;
7287   struct ia64_unw_table_entry * tep;
7288   Elf_Internal_Shdr * relsec;
7289   Elf_Internal_Rela * rela;
7290   Elf_Internal_Rela * rp;
7291   unsigned char * table;
7292   unsigned char * tp;
7293   Elf_Internal_Sym * sym;
7294   const char * relname;
7295
7296   aux->table_len = 0;
7297
7298   /* First, find the starting address of the segment that includes
7299      this section: */
7300
7301   if (elf_header.e_phnum)
7302     {
7303       if (! get_program_headers (file))
7304           return FALSE;
7305
7306       for (seg = program_headers;
7307            seg < program_headers + elf_header.e_phnum;
7308            ++seg)
7309         {
7310           if (seg->p_type != PT_LOAD)
7311             continue;
7312
7313           if (sec->sh_addr >= seg->p_vaddr
7314               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7315             {
7316               aux->seg_base = seg->p_vaddr;
7317               break;
7318             }
7319         }
7320     }
7321
7322   /* Second, build the unwind table from the contents of the unwind section:  */
7323   size = sec->sh_size;
7324   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7325                                       _("unwind table"));
7326   if (!table)
7327     return FALSE;
7328
7329   aux->table_len = size / (3 * eh_addr_size);
7330   aux->table = (struct ia64_unw_table_entry *)
7331     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7332   tep = aux->table;
7333
7334   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7335     {
7336       tep->start.section = SHN_UNDEF;
7337       tep->end.section   = SHN_UNDEF;
7338       tep->info.section  = SHN_UNDEF;
7339       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7340       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7341       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7342       tep->start.offset += aux->seg_base;
7343       tep->end.offset   += aux->seg_base;
7344       tep->info.offset  += aux->seg_base;
7345     }
7346   free (table);
7347
7348   /* Third, apply any relocations to the unwind table:  */
7349   for (relsec = section_headers;
7350        relsec < section_headers + elf_header.e_shnum;
7351        ++relsec)
7352     {
7353       if (relsec->sh_type != SHT_RELA
7354           || relsec->sh_info >= elf_header.e_shnum
7355           || section_headers + relsec->sh_info != sec)
7356         continue;
7357
7358       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7359                               & rela, & nrelas))
7360         {
7361           free (aux->table);
7362           aux->table = NULL;
7363           aux->table_len = 0;
7364           return FALSE;
7365         }
7366
7367       for (rp = rela; rp < rela + nrelas; ++rp)
7368         {
7369           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7370           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7371
7372           /* PR 17531: file: 9fa67536.  */
7373           if (relname == NULL)
7374             {
7375               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7376               continue;
7377             }
7378
7379           if (! const_strneq (relname, "R_IA64_SEGREL"))
7380             {
7381               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7382               continue;
7383             }
7384
7385           i = rp->r_offset / (3 * eh_addr_size);
7386
7387           /* PR 17531: file: 5bc8d9bf.  */
7388           if (i >= aux->table_len)
7389             {
7390               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7391               continue;
7392             }
7393
7394           switch (rp->r_offset / eh_addr_size % 3)
7395             {
7396             case 0:
7397               aux->table[i].start.section = sym->st_shndx;
7398               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7399               break;
7400             case 1:
7401               aux->table[i].end.section   = sym->st_shndx;
7402               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7403               break;
7404             case 2:
7405               aux->table[i].info.section  = sym->st_shndx;
7406               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7407               break;
7408             default:
7409               break;
7410             }
7411         }
7412
7413       free (rela);
7414     }
7415
7416   return TRUE;
7417 }
7418
7419 static bfd_boolean
7420 ia64_process_unwind (FILE * file)
7421 {
7422   Elf_Internal_Shdr * sec;
7423   Elf_Internal_Shdr * unwsec = NULL;
7424   Elf_Internal_Shdr * strsec;
7425   unsigned long i, unwcount = 0, unwstart = 0;
7426   struct ia64_unw_aux_info aux;
7427   bfd_boolean res = TRUE;
7428
7429   memset (& aux, 0, sizeof (aux));
7430
7431   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7432     {
7433       if (sec->sh_type == SHT_SYMTAB
7434           && sec->sh_link < elf_header.e_shnum)
7435         {
7436           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7437
7438           strsec = section_headers + sec->sh_link;
7439           if (aux.strtab != NULL)
7440             {
7441               error (_("Multiple auxillary string tables encountered\n"));
7442               free (aux.strtab);
7443               res = FALSE;
7444             }
7445           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7446                                           1, strsec->sh_size,
7447                                           _("string table"));
7448           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7449         }
7450       else if (sec->sh_type == SHT_IA_64_UNWIND)
7451         unwcount++;
7452     }
7453
7454   if (!unwcount)
7455     printf (_("\nThere are no unwind sections in this file.\n"));
7456
7457   while (unwcount-- > 0)
7458     {
7459       char * suffix;
7460       size_t len, len2;
7461
7462       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7463            i < elf_header.e_shnum; ++i, ++sec)
7464         if (sec->sh_type == SHT_IA_64_UNWIND)
7465           {
7466             unwsec = sec;
7467             break;
7468           }
7469       /* We have already counted the number of SHT_IA64_UNWIND
7470          sections so the loop above should never fail.  */
7471       assert (unwsec != NULL);
7472
7473       unwstart = i + 1;
7474       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7475
7476       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7477         {
7478           /* We need to find which section group it is in.  */
7479           struct group_list * g;
7480
7481           if (section_headers_groups == NULL
7482               || section_headers_groups [i] == NULL)
7483             i = elf_header.e_shnum;
7484           else
7485             {
7486               g = section_headers_groups [i]->root;
7487
7488               for (; g != NULL; g = g->next)
7489                 {
7490                   sec = section_headers + g->section_index;
7491
7492                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7493                     break;
7494                 }
7495
7496               if (g == NULL)
7497                 i = elf_header.e_shnum;
7498             }
7499         }
7500       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7501         {
7502           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7503           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7504           suffix = SECTION_NAME (unwsec) + len;
7505           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7506                ++i, ++sec)
7507             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7508                 && streq (SECTION_NAME (sec) + len2, suffix))
7509               break;
7510         }
7511       else
7512         {
7513           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7514              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7515           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7516           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7517           suffix = "";
7518           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7519             suffix = SECTION_NAME (unwsec) + len;
7520           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7521                ++i, ++sec)
7522             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7523                 && streq (SECTION_NAME (sec) + len2, suffix))
7524               break;
7525         }
7526
7527       if (i == elf_header.e_shnum)
7528         {
7529           printf (_("\nCould not find unwind info section for "));
7530
7531           if (string_table == NULL)
7532             printf ("%d", unwsec->sh_name);
7533           else
7534             printf ("'%s'", printable_section_name (unwsec));
7535         }
7536       else
7537         {
7538           aux.info_addr = sec->sh_addr;
7539           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7540                                                  sec->sh_size,
7541                                                  _("unwind info"));
7542           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7543
7544           printf (_("\nUnwind section "));
7545
7546           if (string_table == NULL)
7547             printf ("%d", unwsec->sh_name);
7548           else
7549             printf ("'%s'", printable_section_name (unwsec));
7550
7551           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7552                   (unsigned long) unwsec->sh_offset,
7553                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7554
7555           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7556               && aux.table_len > 0)
7557             dump_ia64_unwind (& aux);
7558
7559           if (aux.table)
7560             free ((char *) aux.table);
7561           if (aux.info)
7562             free ((char *) aux.info);
7563           aux.table = NULL;
7564           aux.info = NULL;
7565         }
7566     }
7567
7568   if (aux.symtab)
7569     free (aux.symtab);
7570   if (aux.strtab)
7571     free ((char *) aux.strtab);
7572
7573   return res;
7574 }
7575
7576 struct hppa_unw_table_entry
7577 {
7578   struct absaddr start;
7579   struct absaddr end;
7580   unsigned int Cannot_unwind:1;                 /* 0 */
7581   unsigned int Millicode:1;                     /* 1 */
7582   unsigned int Millicode_save_sr0:1;            /* 2 */
7583   unsigned int Region_description:2;            /* 3..4 */
7584   unsigned int reserved1:1;                     /* 5 */
7585   unsigned int Entry_SR:1;                      /* 6 */
7586   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7587   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7588   unsigned int Args_stored:1;                   /* 16 */
7589   unsigned int Variable_Frame:1;                /* 17 */
7590   unsigned int Separate_Package_Body:1;         /* 18 */
7591   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7592   unsigned int Stack_Overflow_Check:1;          /* 20 */
7593   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7594   unsigned int Ada_Region:1;                    /* 22 */
7595   unsigned int cxx_info:1;                      /* 23 */
7596   unsigned int cxx_try_catch:1;                 /* 24 */
7597   unsigned int sched_entry_seq:1;               /* 25 */
7598   unsigned int reserved2:1;                     /* 26 */
7599   unsigned int Save_SP:1;                       /* 27 */
7600   unsigned int Save_RP:1;                       /* 28 */
7601   unsigned int Save_MRP_in_frame:1;             /* 29 */
7602   unsigned int extn_ptr_defined:1;              /* 30 */
7603   unsigned int Cleanup_defined:1;               /* 31 */
7604
7605   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7606   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7607   unsigned int Large_frame:1;                   /* 2 */
7608   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7609   unsigned int reserved4:1;                     /* 4 */
7610   unsigned int Total_frame_size:27;             /* 5..31 */
7611 };
7612
7613 struct hppa_unw_aux_info
7614 {
7615   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7616   unsigned long                  table_len;     /* Length of unwind table.  */
7617   bfd_vma                        seg_base;      /* Starting address of segment.  */
7618   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7619   unsigned long                  nsyms;         /* Number of symbols.  */
7620   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7621   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7622   char *                         strtab;        /* The string table.  */
7623   unsigned long                  strtab_size;   /* Size of string table.  */
7624 };
7625
7626 static bfd_boolean
7627 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7628 {
7629   struct hppa_unw_table_entry * tp;
7630   unsigned long j, nfuns;
7631   bfd_boolean res = TRUE;
7632
7633   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7634   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7635     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7636       aux->funtab[nfuns++] = aux->symtab[j];
7637   aux->nfuns = nfuns;
7638   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7639
7640   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7641     {
7642       bfd_vma offset;
7643       const char * procname;
7644
7645       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7646                                aux->strtab_size, tp->start, &procname,
7647                                &offset);
7648
7649       fputs ("\n<", stdout);
7650
7651       if (procname)
7652         {
7653           fputs (procname, stdout);
7654
7655           if (offset)
7656             printf ("+%lx", (unsigned long) offset);
7657         }
7658
7659       fputs (">: [", stdout);
7660       print_vma (tp->start.offset, PREFIX_HEX);
7661       fputc ('-', stdout);
7662       print_vma (tp->end.offset, PREFIX_HEX);
7663       printf ("]\n\t");
7664
7665 #define PF(_m) if (tp->_m) printf (#_m " ");
7666 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7667       PF(Cannot_unwind);
7668       PF(Millicode);
7669       PF(Millicode_save_sr0);
7670       /* PV(Region_description);  */
7671       PF(Entry_SR);
7672       PV(Entry_FR);
7673       PV(Entry_GR);
7674       PF(Args_stored);
7675       PF(Variable_Frame);
7676       PF(Separate_Package_Body);
7677       PF(Frame_Extension_Millicode);
7678       PF(Stack_Overflow_Check);
7679       PF(Two_Instruction_SP_Increment);
7680       PF(Ada_Region);
7681       PF(cxx_info);
7682       PF(cxx_try_catch);
7683       PF(sched_entry_seq);
7684       PF(Save_SP);
7685       PF(Save_RP);
7686       PF(Save_MRP_in_frame);
7687       PF(extn_ptr_defined);
7688       PF(Cleanup_defined);
7689       PF(MPE_XL_interrupt_marker);
7690       PF(HP_UX_interrupt_marker);
7691       PF(Large_frame);
7692       PF(Pseudo_SP_Set);
7693       PV(Total_frame_size);
7694 #undef PF
7695 #undef PV
7696     }
7697
7698   printf ("\n");
7699
7700   free (aux->funtab);
7701
7702   return res;
7703 }
7704
7705 static bfd_boolean
7706 slurp_hppa_unwind_table (FILE * file,
7707                          struct hppa_unw_aux_info * aux,
7708                          Elf_Internal_Shdr * sec)
7709 {
7710   unsigned long size, unw_ent_size, nentries, nrelas, i;
7711   Elf_Internal_Phdr * seg;
7712   struct hppa_unw_table_entry * tep;
7713   Elf_Internal_Shdr * relsec;
7714   Elf_Internal_Rela * rela;
7715   Elf_Internal_Rela * rp;
7716   unsigned char * table;
7717   unsigned char * tp;
7718   Elf_Internal_Sym * sym;
7719   const char * relname;
7720
7721   /* First, find the starting address of the segment that includes
7722      this section.  */
7723   if (elf_header.e_phnum)
7724     {
7725       if (! get_program_headers (file))
7726         return FALSE;
7727
7728       for (seg = program_headers;
7729            seg < program_headers + elf_header.e_phnum;
7730            ++seg)
7731         {
7732           if (seg->p_type != PT_LOAD)
7733             continue;
7734
7735           if (sec->sh_addr >= seg->p_vaddr
7736               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7737             {
7738               aux->seg_base = seg->p_vaddr;
7739               break;
7740             }
7741         }
7742     }
7743
7744   /* Second, build the unwind table from the contents of the unwind
7745      section.  */
7746   size = sec->sh_size;
7747   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7748                                       _("unwind table"));
7749   if (!table)
7750     return FALSE;
7751
7752   unw_ent_size = 16;
7753   nentries = size / unw_ent_size;
7754   size = unw_ent_size * nentries;
7755
7756   tep = aux->table = (struct hppa_unw_table_entry *)
7757       xcmalloc (nentries, sizeof (aux->table[0]));
7758
7759   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7760     {
7761       unsigned int tmp1, tmp2;
7762
7763       tep->start.section = SHN_UNDEF;
7764       tep->end.section   = SHN_UNDEF;
7765
7766       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7767       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7768       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7769       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7770
7771       tep->start.offset += aux->seg_base;
7772       tep->end.offset   += aux->seg_base;
7773
7774       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7775       tep->Millicode = (tmp1 >> 30) & 0x1;
7776       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7777       tep->Region_description = (tmp1 >> 27) & 0x3;
7778       tep->reserved1 = (tmp1 >> 26) & 0x1;
7779       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7780       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7781       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7782       tep->Args_stored = (tmp1 >> 15) & 0x1;
7783       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7784       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7785       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7786       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7787       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7788       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7789       tep->cxx_info = (tmp1 >> 8) & 0x1;
7790       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7791       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7792       tep->reserved2 = (tmp1 >> 5) & 0x1;
7793       tep->Save_SP = (tmp1 >> 4) & 0x1;
7794       tep->Save_RP = (tmp1 >> 3) & 0x1;
7795       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7796       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7797       tep->Cleanup_defined = tmp1 & 0x1;
7798
7799       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7800       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7801       tep->Large_frame = (tmp2 >> 29) & 0x1;
7802       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7803       tep->reserved4 = (tmp2 >> 27) & 0x1;
7804       tep->Total_frame_size = tmp2 & 0x7ffffff;
7805     }
7806   free (table);
7807
7808   /* Third, apply any relocations to the unwind table.  */
7809   for (relsec = section_headers;
7810        relsec < section_headers + elf_header.e_shnum;
7811        ++relsec)
7812     {
7813       if (relsec->sh_type != SHT_RELA
7814           || relsec->sh_info >= elf_header.e_shnum
7815           || section_headers + relsec->sh_info != sec)
7816         continue;
7817
7818       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7819                               & rela, & nrelas))
7820         return FALSE;
7821
7822       for (rp = rela; rp < rela + nrelas; ++rp)
7823         {
7824           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7825           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7826
7827           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7828           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7829             {
7830               warn (_("Skipping unexpected relocation type %s\n"), relname);
7831               continue;
7832             }
7833
7834           i = rp->r_offset / unw_ent_size;
7835
7836           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7837             {
7838             case 0:
7839               aux->table[i].start.section = sym->st_shndx;
7840               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7841               break;
7842             case 1:
7843               aux->table[i].end.section   = sym->st_shndx;
7844               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7845               break;
7846             default:
7847               break;
7848             }
7849         }
7850
7851       free (rela);
7852     }
7853
7854   aux->table_len = nentries;
7855
7856   return TRUE;
7857 }
7858
7859 static bfd_boolean
7860 hppa_process_unwind (FILE * file)
7861 {
7862   struct hppa_unw_aux_info aux;
7863   Elf_Internal_Shdr * unwsec = NULL;
7864   Elf_Internal_Shdr * strsec;
7865   Elf_Internal_Shdr * sec;
7866   unsigned long i;
7867   bfd_boolean res = TRUE;
7868
7869   if (string_table == NULL)
7870     return FALSE;
7871
7872   memset (& aux, 0, sizeof (aux));
7873
7874   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7875     {
7876       if (sec->sh_type == SHT_SYMTAB
7877           && sec->sh_link < elf_header.e_shnum)
7878         {
7879           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7880
7881           strsec = section_headers + sec->sh_link;
7882           if (aux.strtab != NULL)
7883             {
7884               error (_("Multiple auxillary string tables encountered\n"));
7885               free (aux.strtab);
7886               res = FALSE;
7887             }
7888           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7889                                           1, strsec->sh_size,
7890                                           _("string table"));
7891           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7892         }
7893       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7894         unwsec = sec;
7895     }
7896
7897   if (!unwsec)
7898     printf (_("\nThere are no unwind sections in this file.\n"));
7899
7900   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7901     {
7902       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7903         {
7904           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7905                   printable_section_name (sec),
7906                   (unsigned long) sec->sh_offset,
7907                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7908
7909           if (! slurp_hppa_unwind_table (file, &aux, sec))
7910             res = FALSE;
7911
7912           if (aux.table_len > 0)
7913             {
7914               if (! dump_hppa_unwind (&aux))
7915                 res = FALSE;
7916             }
7917
7918           if (aux.table)
7919             free ((char *) aux.table);
7920           aux.table = NULL;
7921         }
7922     }
7923
7924   if (aux.symtab)
7925     free (aux.symtab);
7926   if (aux.strtab)
7927     free ((char *) aux.strtab);
7928
7929   return res;
7930 }
7931
7932 struct arm_section
7933 {
7934   unsigned char *      data;            /* The unwind data.  */
7935   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7936   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7937   unsigned long        nrelas;          /* The number of relocations.  */
7938   unsigned int         rel_type;        /* REL or RELA ?  */
7939   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7940 };
7941
7942 struct arm_unw_aux_info
7943 {
7944   FILE *              file;             /* The file containing the unwind sections.  */
7945   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
7946   unsigned long       nsyms;            /* Number of symbols.  */
7947   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
7948   unsigned long       nfuns;            /* Number of these symbols.  */
7949   char *              strtab;           /* The file's string table.  */
7950   unsigned long       strtab_size;      /* Size of string table.  */
7951 };
7952
7953 static const char *
7954 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7955                         bfd_vma fn, struct absaddr addr)
7956 {
7957   const char *procname;
7958   bfd_vma sym_offset;
7959
7960   if (addr.section == SHN_UNDEF)
7961     addr.offset = fn;
7962
7963   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7964                            aux->strtab_size, addr, &procname,
7965                            &sym_offset);
7966
7967   print_vma (fn, PREFIX_HEX);
7968
7969   if (procname)
7970     {
7971       fputs (" <", stdout);
7972       fputs (procname, stdout);
7973
7974       if (sym_offset)
7975         printf ("+0x%lx", (unsigned long) sym_offset);
7976       fputc ('>', stdout);
7977     }
7978
7979   return procname;
7980 }
7981
7982 static void
7983 arm_free_section (struct arm_section *arm_sec)
7984 {
7985   if (arm_sec->data != NULL)
7986     free (arm_sec->data);
7987
7988   if (arm_sec->rela != NULL)
7989     free (arm_sec->rela);
7990 }
7991
7992 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7993       cached section and install SEC instead.
7994    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7995       and return its valued in * WORDP, relocating if necessary.
7996    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7997       relocation's offset in ADDR.
7998    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7999       into the string table of the symbol associated with the reloc.  If no
8000       reloc was applied store -1 there.
8001    5) Return TRUE upon success, FALSE otherwise.  */
8002
8003 static bfd_boolean
8004 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8005                          struct arm_section *       arm_sec,
8006                          Elf_Internal_Shdr *        sec,
8007                          bfd_vma                    word_offset,
8008                          unsigned int *             wordp,
8009                          struct absaddr *           addr,
8010                          bfd_vma *                  sym_name)
8011 {
8012   Elf_Internal_Rela *rp;
8013   Elf_Internal_Sym *sym;
8014   const char * relname;
8015   unsigned int word;
8016   bfd_boolean wrapped;
8017
8018   if (sec == NULL || arm_sec == NULL)
8019     return FALSE;
8020
8021   addr->section = SHN_UNDEF;
8022   addr->offset = 0;
8023
8024   if (sym_name != NULL)
8025     *sym_name = (bfd_vma) -1;
8026
8027   /* If necessary, update the section cache.  */
8028   if (sec != arm_sec->sec)
8029     {
8030       Elf_Internal_Shdr *relsec;
8031
8032       arm_free_section (arm_sec);
8033
8034       arm_sec->sec = sec;
8035       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8036                                 sec->sh_size, _("unwind data"));
8037       arm_sec->rela = NULL;
8038       arm_sec->nrelas = 0;
8039
8040       for (relsec = section_headers;
8041            relsec < section_headers + elf_header.e_shnum;
8042            ++relsec)
8043         {
8044           if (relsec->sh_info >= elf_header.e_shnum
8045               || section_headers + relsec->sh_info != sec
8046               /* PR 15745: Check the section type as well.  */
8047               || (relsec->sh_type != SHT_REL
8048                   && relsec->sh_type != SHT_RELA))
8049             continue;
8050
8051           arm_sec->rel_type = relsec->sh_type;
8052           if (relsec->sh_type == SHT_REL)
8053             {
8054               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8055                                      relsec->sh_size,
8056                                      & arm_sec->rela, & arm_sec->nrelas))
8057                 return FALSE;
8058             }
8059           else /* relsec->sh_type == SHT_RELA */
8060             {
8061               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8062                                       relsec->sh_size,
8063                                       & arm_sec->rela, & arm_sec->nrelas))
8064                 return FALSE;
8065             }
8066           break;
8067         }
8068
8069       arm_sec->next_rela = arm_sec->rela;
8070     }
8071
8072   /* If there is no unwind data we can do nothing.  */
8073   if (arm_sec->data == NULL)
8074     return FALSE;
8075
8076   /* If the offset is invalid then fail.  */
8077   if (/* PR 21343 *//* PR 18879 */
8078       sec->sh_size < 4
8079       || word_offset > (sec->sh_size - 4)
8080       || ((bfd_signed_vma) word_offset) < 0)
8081     return FALSE;
8082
8083   /* Get the word at the required offset.  */
8084   word = byte_get (arm_sec->data + word_offset, 4);
8085
8086   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8087   if (arm_sec->rela == NULL)
8088     {
8089       * wordp = word;
8090       return TRUE;
8091     }
8092
8093   /* Look through the relocs to find the one that applies to the provided offset.  */
8094   wrapped = FALSE;
8095   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8096     {
8097       bfd_vma prelval, offset;
8098
8099       if (rp->r_offset > word_offset && !wrapped)
8100         {
8101           rp = arm_sec->rela;
8102           wrapped = TRUE;
8103         }
8104       if (rp->r_offset > word_offset)
8105         break;
8106
8107       if (rp->r_offset & 3)
8108         {
8109           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8110                 (unsigned long) rp->r_offset);
8111           continue;
8112         }
8113
8114       if (rp->r_offset < word_offset)
8115         continue;
8116
8117       /* PR 17531: file: 027-161405-0.004  */
8118       if (aux->symtab == NULL)
8119         continue;
8120
8121       if (arm_sec->rel_type == SHT_REL)
8122         {
8123           offset = word & 0x7fffffff;
8124           if (offset & 0x40000000)
8125             offset |= ~ (bfd_vma) 0x7fffffff;
8126         }
8127       else if (arm_sec->rel_type == SHT_RELA)
8128         offset = rp->r_addend;
8129       else
8130         {
8131           error (_("Unknown section relocation type %d encountered\n"),
8132                  arm_sec->rel_type);
8133           break;
8134         }
8135
8136       /* PR 17531 file: 027-1241568-0.004.  */
8137       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8138         {
8139           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8140                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8141           break;
8142         }
8143
8144       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8145       offset += sym->st_value;
8146       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8147
8148       /* Check that we are processing the expected reloc type.  */
8149       if (elf_header.e_machine == EM_ARM)
8150         {
8151           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8152           if (relname == NULL)
8153             {
8154               warn (_("Skipping unknown ARM relocation type: %d\n"),
8155                     (int) ELF32_R_TYPE (rp->r_info));
8156               continue;
8157             }
8158
8159           if (streq (relname, "R_ARM_NONE"))
8160               continue;
8161
8162           if (! streq (relname, "R_ARM_PREL31"))
8163             {
8164               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8165               continue;
8166             }
8167         }
8168       else if (elf_header.e_machine == EM_TI_C6000)
8169         {
8170           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8171           if (relname == NULL)
8172             {
8173               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8174                     (int) ELF32_R_TYPE (rp->r_info));
8175               continue;
8176             }
8177
8178           if (streq (relname, "R_C6000_NONE"))
8179             continue;
8180
8181           if (! streq (relname, "R_C6000_PREL31"))
8182             {
8183               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8184               continue;
8185             }
8186
8187           prelval >>= 1;
8188         }
8189       else
8190         {
8191           /* This function currently only supports ARM and TI unwinders.  */
8192           warn (_("Only TI and ARM unwinders are currently supported\n"));
8193           break;
8194         }
8195
8196       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8197       addr->section = sym->st_shndx;
8198       addr->offset = offset;
8199
8200       if (sym_name)
8201         * sym_name = sym->st_name;
8202       break;
8203     }
8204
8205   *wordp = word;
8206   arm_sec->next_rela = rp;
8207
8208   return TRUE;
8209 }
8210
8211 static const char *tic6x_unwind_regnames[16] =
8212 {
8213   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8214   "A14", "A13", "A12", "A11", "A10",
8215   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8216 };
8217
8218 static void
8219 decode_tic6x_unwind_regmask (unsigned int mask)
8220 {
8221   int i;
8222
8223   for (i = 12; mask; mask >>= 1, i--)
8224     {
8225       if (mask & 1)
8226         {
8227           fputs (tic6x_unwind_regnames[i], stdout);
8228           if (mask > 1)
8229             fputs (", ", stdout);
8230         }
8231     }
8232 }
8233
8234 #define ADVANCE                                                 \
8235   if (remaining == 0 && more_words)                             \
8236     {                                                           \
8237       data_offset += 4;                                         \
8238       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8239                                      data_offset, & word, & addr, NULL))        \
8240         return FALSE;                                           \
8241       remaining = 4;                                            \
8242       more_words--;                                             \
8243     }                                                           \
8244
8245 #define GET_OP(OP)                      \
8246   ADVANCE;                              \
8247   if (remaining)                        \
8248     {                                   \
8249       remaining--;                      \
8250       (OP) = word >> 24;                \
8251       word <<= 8;                       \
8252     }                                   \
8253   else                                  \
8254     {                                   \
8255       printf (_("[Truncated opcode]\n"));       \
8256       return FALSE;                     \
8257     }                                   \
8258   printf ("0x%02x ", OP)
8259
8260 static bfd_boolean
8261 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8262                             unsigned int               word,
8263                             unsigned int               remaining,
8264                             unsigned int               more_words,
8265                             bfd_vma                    data_offset,
8266                             Elf_Internal_Shdr *        data_sec,
8267                             struct arm_section *       data_arm_sec)
8268 {
8269   struct absaddr addr;
8270   bfd_boolean res = TRUE;
8271
8272   /* Decode the unwinding instructions.  */
8273   while (1)
8274     {
8275       unsigned int op, op2;
8276
8277       ADVANCE;
8278       if (remaining == 0)
8279         break;
8280       remaining--;
8281       op = word >> 24;
8282       word <<= 8;
8283
8284       printf ("  0x%02x ", op);
8285
8286       if ((op & 0xc0) == 0x00)
8287         {
8288           int offset = ((op & 0x3f) << 2) + 4;
8289
8290           printf ("     vsp = vsp + %d", offset);
8291         }
8292       else if ((op & 0xc0) == 0x40)
8293         {
8294           int offset = ((op & 0x3f) << 2) + 4;
8295
8296           printf ("     vsp = vsp - %d", offset);
8297         }
8298       else if ((op & 0xf0) == 0x80)
8299         {
8300           GET_OP (op2);
8301           if (op == 0x80 && op2 == 0)
8302             printf (_("Refuse to unwind"));
8303           else
8304             {
8305               unsigned int mask = ((op & 0x0f) << 8) | op2;
8306               bfd_boolean first = TRUE;
8307               int i;
8308
8309               printf ("pop {");
8310               for (i = 0; i < 12; i++)
8311                 if (mask & (1 << i))
8312                   {
8313                     if (first)
8314                       first = FALSE;
8315                     else
8316                       printf (", ");
8317                     printf ("r%d", 4 + i);
8318                   }
8319               printf ("}");
8320             }
8321         }
8322       else if ((op & 0xf0) == 0x90)
8323         {
8324           if (op == 0x9d || op == 0x9f)
8325             printf (_("     [Reserved]"));
8326           else
8327             printf ("     vsp = r%d", op & 0x0f);
8328         }
8329       else if ((op & 0xf0) == 0xa0)
8330         {
8331           int end = 4 + (op & 0x07);
8332           bfd_boolean first = TRUE;
8333           int i;
8334
8335           printf ("     pop {");
8336           for (i = 4; i <= end; i++)
8337             {
8338               if (first)
8339                 first = FALSE;
8340               else
8341                 printf (", ");
8342               printf ("r%d", i);
8343             }
8344           if (op & 0x08)
8345             {
8346               if (!first)
8347                 printf (", ");
8348               printf ("r14");
8349             }
8350           printf ("}");
8351         }
8352       else if (op == 0xb0)
8353         printf (_("     finish"));
8354       else if (op == 0xb1)
8355         {
8356           GET_OP (op2);
8357           if (op2 == 0 || (op2 & 0xf0) != 0)
8358             printf (_("[Spare]"));
8359           else
8360             {
8361               unsigned int mask = op2 & 0x0f;
8362               bfd_boolean first = TRUE;
8363               int i;
8364
8365               printf ("pop {");
8366               for (i = 0; i < 12; i++)
8367                 if (mask & (1 << i))
8368                   {
8369                     if (first)
8370                       first = FALSE;
8371                     else
8372                       printf (", ");
8373                     printf ("r%d", i);
8374                   }
8375               printf ("}");
8376             }
8377         }
8378       else if (op == 0xb2)
8379         {
8380           unsigned char buf[9];
8381           unsigned int i, len;
8382           unsigned long offset;
8383
8384           for (i = 0; i < sizeof (buf); i++)
8385             {
8386               GET_OP (buf[i]);
8387               if ((buf[i] & 0x80) == 0)
8388                 break;
8389             }
8390           if (i == sizeof (buf))
8391             {
8392               error (_("corrupt change to vsp"));
8393               res = FALSE;
8394             }
8395           else
8396             {
8397               offset = read_uleb128 (buf, &len, buf + i + 1);
8398               assert (len == i + 1);
8399               offset = offset * 4 + 0x204;
8400               printf ("vsp = vsp + %ld", offset);
8401             }
8402         }
8403       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8404         {
8405           unsigned int first, last;
8406
8407           GET_OP (op2);
8408           first = op2 >> 4;
8409           last = op2 & 0x0f;
8410           if (op == 0xc8)
8411             first = first + 16;
8412           printf ("pop {D%d", first);
8413           if (last)
8414             printf ("-D%d", first + last);
8415           printf ("}");
8416         }
8417       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8418         {
8419           unsigned int count = op & 0x07;
8420
8421           printf ("pop {D8");
8422           if (count)
8423             printf ("-D%d", 8 + count);
8424           printf ("}");
8425         }
8426       else if (op >= 0xc0 && op <= 0xc5)
8427         {
8428           unsigned int count = op & 0x07;
8429
8430           printf ("     pop {wR10");
8431           if (count)
8432             printf ("-wR%d", 10 + count);
8433           printf ("}");
8434         }
8435       else if (op == 0xc6)
8436         {
8437           unsigned int first, last;
8438
8439           GET_OP (op2);
8440           first = op2 >> 4;
8441           last = op2 & 0x0f;
8442           printf ("pop {wR%d", first);
8443           if (last)
8444             printf ("-wR%d", first + last);
8445           printf ("}");
8446         }
8447       else if (op == 0xc7)
8448         {
8449           GET_OP (op2);
8450           if (op2 == 0 || (op2 & 0xf0) != 0)
8451             printf (_("[Spare]"));
8452           else
8453             {
8454               unsigned int mask = op2 & 0x0f;
8455               bfd_boolean first = TRUE;
8456               int i;
8457
8458               printf ("pop {");
8459               for (i = 0; i < 4; i++)
8460                 if (mask & (1 << i))
8461                   {
8462                     if (first)
8463                       first = FALSE;
8464                     else
8465                       printf (", ");
8466                     printf ("wCGR%d", i);
8467                   }
8468               printf ("}");
8469             }
8470         }
8471       else
8472         {
8473           printf (_("     [unsupported opcode]"));
8474           res = FALSE;
8475         }
8476
8477       printf ("\n");
8478     }
8479
8480   return res;
8481 }
8482
8483 static bfd_boolean
8484 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8485                               unsigned int               word,
8486                               unsigned int               remaining,
8487                               unsigned int               more_words,
8488                               bfd_vma                    data_offset,
8489                               Elf_Internal_Shdr *        data_sec,
8490                               struct arm_section *       data_arm_sec)
8491 {
8492   struct absaddr addr;
8493
8494   /* Decode the unwinding instructions.  */
8495   while (1)
8496     {
8497       unsigned int op, op2;
8498
8499       ADVANCE;
8500       if (remaining == 0)
8501         break;
8502       remaining--;
8503       op = word >> 24;
8504       word <<= 8;
8505
8506       printf ("  0x%02x ", op);
8507
8508       if ((op & 0xc0) == 0x00)
8509         {
8510           int offset = ((op & 0x3f) << 3) + 8;
8511           printf ("     sp = sp + %d", offset);
8512         }
8513       else if ((op & 0xc0) == 0x80)
8514         {
8515           GET_OP (op2);
8516           if (op == 0x80 && op2 == 0)
8517             printf (_("Refuse to unwind"));
8518           else
8519             {
8520               unsigned int mask = ((op & 0x1f) << 8) | op2;
8521               if (op & 0x20)
8522                 printf ("pop compact {");
8523               else
8524                 printf ("pop {");
8525
8526               decode_tic6x_unwind_regmask (mask);
8527               printf("}");
8528             }
8529         }
8530       else if ((op & 0xf0) == 0xc0)
8531         {
8532           unsigned int reg;
8533           unsigned int nregs;
8534           unsigned int i;
8535           const char *name;
8536           struct
8537           {
8538             unsigned int offset;
8539             unsigned int reg;
8540           } regpos[16];
8541
8542           /* Scan entire instruction first so that GET_OP output is not
8543              interleaved with disassembly.  */
8544           nregs = 0;
8545           for (i = 0; nregs < (op & 0xf); i++)
8546             {
8547               GET_OP (op2);
8548               reg = op2 >> 4;
8549               if (reg != 0xf)
8550                 {
8551                   regpos[nregs].offset = i * 2;
8552                   regpos[nregs].reg = reg;
8553                   nregs++;
8554                 }
8555
8556               reg = op2 & 0xf;
8557               if (reg != 0xf)
8558                 {
8559                   regpos[nregs].offset = i * 2 + 1;
8560                   regpos[nregs].reg = reg;
8561                   nregs++;
8562                 }
8563             }
8564
8565           printf (_("pop frame {"));
8566           reg = nregs - 1;
8567           for (i = i * 2; i > 0; i--)
8568             {
8569               if (regpos[reg].offset == i - 1)
8570                 {
8571                   name = tic6x_unwind_regnames[regpos[reg].reg];
8572                   if (reg > 0)
8573                     reg--;
8574                 }
8575               else
8576                 name = _("[pad]");
8577
8578               fputs (name, stdout);
8579               if (i > 1)
8580                 printf (", ");
8581             }
8582
8583           printf ("}");
8584         }
8585       else if (op == 0xd0)
8586         printf ("     MOV FP, SP");
8587       else if (op == 0xd1)
8588         printf ("     __c6xabi_pop_rts");
8589       else if (op == 0xd2)
8590         {
8591           unsigned char buf[9];
8592           unsigned int i, len;
8593           unsigned long offset;
8594
8595           for (i = 0; i < sizeof (buf); i++)
8596             {
8597               GET_OP (buf[i]);
8598               if ((buf[i] & 0x80) == 0)
8599                 break;
8600             }
8601           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8602           if (i == sizeof (buf))
8603             {
8604               warn (_("Corrupt stack pointer adjustment detected\n"));
8605               return FALSE;
8606             }
8607
8608           offset = read_uleb128 (buf, &len, buf + i + 1);
8609           assert (len == i + 1);
8610           offset = offset * 8 + 0x408;
8611           printf (_("sp = sp + %ld"), offset);
8612         }
8613       else if ((op & 0xf0) == 0xe0)
8614         {
8615           if ((op & 0x0f) == 7)
8616             printf ("     RETURN");
8617           else
8618             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8619         }
8620       else
8621         {
8622           printf (_("     [unsupported opcode]"));
8623         }
8624       putchar ('\n');
8625     }
8626
8627   return TRUE;
8628 }
8629
8630 static bfd_vma
8631 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8632 {
8633   bfd_vma offset;
8634
8635   offset = word & 0x7fffffff;
8636   if (offset & 0x40000000)
8637     offset |= ~ (bfd_vma) 0x7fffffff;
8638
8639   if (elf_header.e_machine == EM_TI_C6000)
8640     offset <<= 1;
8641
8642   return offset + where;
8643 }
8644
8645 static bfd_boolean
8646 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8647                    unsigned int               word,
8648                    unsigned int               remaining,
8649                    bfd_vma                    data_offset,
8650                    Elf_Internal_Shdr *        data_sec,
8651                    struct arm_section *       data_arm_sec)
8652 {
8653   int per_index;
8654   unsigned int more_words = 0;
8655   struct absaddr addr;
8656   bfd_vma sym_name = (bfd_vma) -1;
8657   bfd_boolean res = FALSE;
8658
8659   if (remaining == 0)
8660     {
8661       /* Fetch the first word.
8662          Note - when decoding an object file the address extracted
8663          here will always be 0.  So we also pass in the sym_name
8664          parameter so that we can find the symbol associated with
8665          the personality routine.  */
8666       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8667                                      & word, & addr, & sym_name))
8668         return FALSE;
8669
8670       remaining = 4;
8671     }
8672
8673   if ((word & 0x80000000) == 0)
8674     {
8675       /* Expand prel31 for personality routine.  */
8676       bfd_vma fn;
8677       const char *procname;
8678
8679       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8680       printf (_("  Personality routine: "));
8681       if (fn == 0
8682           && addr.section == SHN_UNDEF && addr.offset == 0
8683           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8684         {
8685           procname = aux->strtab + sym_name;
8686           print_vma (fn, PREFIX_HEX);
8687           if (procname)
8688             {
8689               fputs (" <", stdout);
8690               fputs (procname, stdout);
8691               fputc ('>', stdout);
8692             }
8693         }
8694       else
8695         procname = arm_print_vma_and_name (aux, fn, addr);
8696       fputc ('\n', stdout);
8697
8698       /* The GCC personality routines use the standard compact
8699          encoding, starting with one byte giving the number of
8700          words.  */
8701       if (procname != NULL
8702           && (const_strneq (procname, "__gcc_personality_v0")
8703               || const_strneq (procname, "__gxx_personality_v0")
8704               || const_strneq (procname, "__gcj_personality_v0")
8705               || const_strneq (procname, "__gnu_objc_personality_v0")))
8706         {
8707           remaining = 0;
8708           more_words = 1;
8709           ADVANCE;
8710           if (!remaining)
8711             {
8712               printf (_("  [Truncated data]\n"));
8713               return FALSE;
8714             }
8715           more_words = word >> 24;
8716           word <<= 8;
8717           remaining--;
8718           per_index = -1;
8719         }
8720       else
8721         return TRUE;
8722     }
8723   else
8724     {
8725       /* ARM EHABI Section 6.3:
8726
8727          An exception-handling table entry for the compact model looks like:
8728
8729            31 30-28 27-24 23-0
8730            -- ----- ----- ----
8731             1   0   index Data for personalityRoutine[index]    */
8732
8733       if (elf_header.e_machine == EM_ARM
8734           && (word & 0x70000000))
8735         {
8736           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8737           res = FALSE;
8738         }
8739
8740       per_index = (word >> 24) & 0x7f;
8741       printf (_("  Compact model index: %d\n"), per_index);
8742       if (per_index == 0)
8743         {
8744           more_words = 0;
8745           word <<= 8;
8746           remaining--;
8747         }
8748       else if (per_index < 3)
8749         {
8750           more_words = (word >> 16) & 0xff;
8751           word <<= 16;
8752           remaining -= 2;
8753         }
8754     }
8755
8756   switch (elf_header.e_machine)
8757     {
8758     case EM_ARM:
8759       if (per_index < 3)
8760         {
8761           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8762                                             data_offset, data_sec, data_arm_sec))
8763             res = FALSE;
8764         }
8765       else
8766         {
8767           warn (_("Unknown ARM compact model index encountered\n"));
8768           printf (_("  [reserved]\n"));
8769           res = FALSE;
8770         }
8771       break;
8772
8773     case EM_TI_C6000:
8774       if (per_index < 3)
8775         {
8776           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8777                                               data_offset, data_sec, data_arm_sec))
8778             res = FALSE;
8779         }
8780       else if (per_index < 5)
8781         {
8782           if (((word >> 17) & 0x7f) == 0x7f)
8783             printf (_("  Restore stack from frame pointer\n"));
8784           else
8785             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8786           printf (_("  Registers restored: "));
8787           if (per_index == 4)
8788             printf (" (compact) ");
8789           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8790           putchar ('\n');
8791           printf (_("  Return register: %s\n"),
8792                   tic6x_unwind_regnames[word & 0xf]);
8793         }
8794       else
8795         printf (_("  [reserved (%d)]\n"), per_index);
8796       break;
8797
8798     default:
8799       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8800              elf_header.e_machine);
8801       res = FALSE;
8802     }
8803
8804   /* Decode the descriptors.  Not implemented.  */
8805
8806   return res;
8807 }
8808
8809 static bfd_boolean
8810 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8811 {
8812   struct arm_section exidx_arm_sec, extab_arm_sec;
8813   unsigned int i, exidx_len;
8814   unsigned long j, nfuns;
8815   bfd_boolean res = TRUE;
8816
8817   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8818   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8819   exidx_len = exidx_sec->sh_size / 8;
8820
8821   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8822   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8823     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8824       aux->funtab[nfuns++] = aux->symtab[j];
8825   aux->nfuns = nfuns;
8826   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8827
8828   for (i = 0; i < exidx_len; i++)
8829     {
8830       unsigned int exidx_fn, exidx_entry;
8831       struct absaddr fn_addr, entry_addr;
8832       bfd_vma fn;
8833
8834       fputc ('\n', stdout);
8835
8836       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8837                                      8 * i, & exidx_fn, & fn_addr, NULL)
8838           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8839                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8840         {
8841           free (aux->funtab);
8842           arm_free_section (& exidx_arm_sec);
8843           arm_free_section (& extab_arm_sec);
8844           return FALSE;
8845         }
8846
8847       /* ARM EHABI, Section 5:
8848          An index table entry consists of 2 words.
8849          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8850       if (exidx_fn & 0x80000000)
8851         {
8852           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8853           res = FALSE;
8854         }
8855
8856       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8857
8858       arm_print_vma_and_name (aux, fn, fn_addr);
8859       fputs (": ", stdout);
8860
8861       if (exidx_entry == 1)
8862         {
8863           print_vma (exidx_entry, PREFIX_HEX);
8864           fputs (" [cantunwind]\n", stdout);
8865         }
8866       else if (exidx_entry & 0x80000000)
8867         {
8868           print_vma (exidx_entry, PREFIX_HEX);
8869           fputc ('\n', stdout);
8870           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8871         }
8872       else
8873         {
8874           bfd_vma table, table_offset = 0;
8875           Elf_Internal_Shdr *table_sec;
8876
8877           fputs ("@", stdout);
8878           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8879           print_vma (table, PREFIX_HEX);
8880           printf ("\n");
8881
8882           /* Locate the matching .ARM.extab.  */
8883           if (entry_addr.section != SHN_UNDEF
8884               && entry_addr.section < elf_header.e_shnum)
8885             {
8886               table_sec = section_headers + entry_addr.section;
8887               table_offset = entry_addr.offset;
8888               /* PR 18879 */
8889               if (table_offset > table_sec->sh_size
8890                   || ((bfd_signed_vma) table_offset) < 0)
8891                 {
8892                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8893                         (unsigned long) table_offset,
8894                         printable_section_name (table_sec));
8895                   res = FALSE;
8896                   continue;
8897                 }
8898             }
8899           else
8900             {
8901               table_sec = find_section_by_address (table);
8902               if (table_sec != NULL)
8903                 table_offset = table - table_sec->sh_addr;
8904             }
8905
8906           if (table_sec == NULL)
8907             {
8908               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8909                     (unsigned long) table);
8910               res = FALSE;
8911               continue;
8912             }
8913
8914           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8915                                    &extab_arm_sec))
8916             res = FALSE;
8917         }
8918     }
8919
8920   printf ("\n");
8921
8922   free (aux->funtab);
8923   arm_free_section (&exidx_arm_sec);
8924   arm_free_section (&extab_arm_sec);
8925
8926   return res;
8927 }
8928
8929 /* Used for both ARM and C6X unwinding tables.  */
8930
8931 static bfd_boolean
8932 arm_process_unwind (FILE *file)
8933 {
8934   struct arm_unw_aux_info aux;
8935   Elf_Internal_Shdr *unwsec = NULL;
8936   Elf_Internal_Shdr *strsec;
8937   Elf_Internal_Shdr *sec;
8938   unsigned long i;
8939   unsigned int sec_type;
8940   bfd_boolean res = TRUE;
8941
8942   switch (elf_header.e_machine)
8943     {
8944     case EM_ARM:
8945       sec_type = SHT_ARM_EXIDX;
8946       break;
8947
8948     case EM_TI_C6000:
8949       sec_type = SHT_C6000_UNWIND;
8950       break;
8951
8952     default:
8953       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8954              elf_header.e_machine);
8955       return FALSE;
8956     }
8957
8958   if (string_table == NULL)
8959     return FALSE;
8960
8961   memset (& aux, 0, sizeof (aux));
8962   aux.file = file;
8963
8964   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8965     {
8966       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8967         {
8968           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8969
8970           strsec = section_headers + sec->sh_link;
8971
8972           /* PR binutils/17531 file: 011-12666-0.004.  */
8973           if (aux.strtab != NULL)
8974             {
8975               error (_("Multiple string tables found in file.\n"));
8976               free (aux.strtab);
8977               res = FALSE;
8978             }
8979           aux.strtab = get_data (NULL, file, strsec->sh_offset,
8980                                  1, strsec->sh_size, _("string table"));
8981           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8982         }
8983       else if (sec->sh_type == sec_type)
8984         unwsec = sec;
8985     }
8986
8987   if (unwsec == NULL)
8988     printf (_("\nThere are no unwind sections in this file.\n"));
8989   else
8990     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8991       {
8992         if (sec->sh_type == sec_type)
8993           {
8994             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8995                     printable_section_name (sec),
8996                     (unsigned long) sec->sh_offset,
8997                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8998
8999             if (! dump_arm_unwind (&aux, sec))
9000               res = FALSE;
9001           }
9002       }
9003
9004   if (aux.symtab)
9005     free (aux.symtab);
9006   if (aux.strtab)
9007     free ((char *) aux.strtab);
9008
9009   return res;
9010 }
9011
9012 static bfd_boolean
9013 process_unwind (FILE * file)
9014 {
9015   struct unwind_handler
9016   {
9017     unsigned int machtype;
9018     bfd_boolean (* handler)(FILE *);
9019   } handlers[] =
9020   {
9021     { EM_ARM, arm_process_unwind },
9022     { EM_IA_64, ia64_process_unwind },
9023     { EM_PARISC, hppa_process_unwind },
9024     { EM_TI_C6000, arm_process_unwind },
9025     { 0, NULL }
9026   };
9027   int i;
9028
9029   if (!do_unwind)
9030     return TRUE;
9031
9032   for (i = 0; handlers[i].handler != NULL; i++)
9033     if (elf_header.e_machine == handlers[i].machtype)
9034       return handlers[i].handler (file);
9035
9036   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9037           get_machine_name (elf_header.e_machine));
9038   return TRUE;
9039 }
9040
9041 static void
9042 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9043 {
9044   switch (entry->d_tag)
9045     {
9046     case DT_MIPS_FLAGS:
9047       if (entry->d_un.d_val == 0)
9048         printf (_("NONE"));
9049       else
9050         {
9051           static const char * opts[] =
9052           {
9053             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9054             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9055             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9056             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9057             "RLD_ORDER_SAFE"
9058           };
9059           unsigned int cnt;
9060           bfd_boolean first = TRUE;
9061
9062           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9063             if (entry->d_un.d_val & (1 << cnt))
9064               {
9065                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9066                 first = FALSE;
9067               }
9068         }
9069       break;
9070
9071     case DT_MIPS_IVERSION:
9072       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9073         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9074       else
9075         {
9076           char buf[40];
9077           sprintf_vma (buf, entry->d_un.d_ptr);
9078           /* Note: coded this way so that there is a single string for translation.  */
9079           printf (_("<corrupt: %s>"), buf);
9080         }
9081       break;
9082
9083     case DT_MIPS_TIME_STAMP:
9084       {
9085         char timebuf[128];
9086         struct tm * tmp;
9087         time_t atime = entry->d_un.d_val;
9088
9089         tmp = gmtime (&atime);
9090         /* PR 17531: file: 6accc532.  */
9091         if (tmp == NULL)
9092           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9093         else
9094           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9095                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9096                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9097         printf (_("Time Stamp: %s"), timebuf);
9098       }
9099       break;
9100
9101     case DT_MIPS_RLD_VERSION:
9102     case DT_MIPS_LOCAL_GOTNO:
9103     case DT_MIPS_CONFLICTNO:
9104     case DT_MIPS_LIBLISTNO:
9105     case DT_MIPS_SYMTABNO:
9106     case DT_MIPS_UNREFEXTNO:
9107     case DT_MIPS_HIPAGENO:
9108     case DT_MIPS_DELTA_CLASS_NO:
9109     case DT_MIPS_DELTA_INSTANCE_NO:
9110     case DT_MIPS_DELTA_RELOC_NO:
9111     case DT_MIPS_DELTA_SYM_NO:
9112     case DT_MIPS_DELTA_CLASSSYM_NO:
9113     case DT_MIPS_COMPACT_SIZE:
9114       print_vma (entry->d_un.d_val, DEC);
9115       break;
9116
9117     default:
9118       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9119     }
9120     putchar ('\n');
9121 }
9122
9123 static void
9124 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9125 {
9126   switch (entry->d_tag)
9127     {
9128     case DT_HP_DLD_FLAGS:
9129       {
9130         static struct
9131         {
9132           long int bit;
9133           const char * str;
9134         }
9135         flags[] =
9136         {
9137           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9138           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9139           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9140           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9141           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9142           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9143           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9144           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9145           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9146           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9147           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9148           { DT_HP_GST, "HP_GST" },
9149           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9150           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9151           { DT_HP_NODELETE, "HP_NODELETE" },
9152           { DT_HP_GROUP, "HP_GROUP" },
9153           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9154         };
9155         bfd_boolean first = TRUE;
9156         size_t cnt;
9157         bfd_vma val = entry->d_un.d_val;
9158
9159         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9160           if (val & flags[cnt].bit)
9161             {
9162               if (! first)
9163                 putchar (' ');
9164               fputs (flags[cnt].str, stdout);
9165               first = FALSE;
9166               val ^= flags[cnt].bit;
9167             }
9168
9169         if (val != 0 || first)
9170           {
9171             if (! first)
9172               putchar (' ');
9173             print_vma (val, HEX);
9174           }
9175       }
9176       break;
9177
9178     default:
9179       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9180       break;
9181     }
9182   putchar ('\n');
9183 }
9184
9185 #ifdef BFD64
9186
9187 /* VMS vs Unix time offset and factor.  */
9188
9189 #define VMS_EPOCH_OFFSET 35067168000000000LL
9190 #define VMS_GRANULARITY_FACTOR 10000000
9191
9192 /* Display a VMS time in a human readable format.  */
9193
9194 static void
9195 print_vms_time (bfd_int64_t vmstime)
9196 {
9197   struct tm *tm;
9198   time_t unxtime;
9199
9200   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9201   tm = gmtime (&unxtime);
9202   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9203           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9204           tm->tm_hour, tm->tm_min, tm->tm_sec);
9205 }
9206 #endif /* BFD64 */
9207
9208 static void
9209 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9210 {
9211   switch (entry->d_tag)
9212     {
9213     case DT_IA_64_PLT_RESERVE:
9214       /* First 3 slots reserved.  */
9215       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9216       printf (" -- ");
9217       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9218       break;
9219
9220     case DT_IA_64_VMS_LINKTIME:
9221 #ifdef BFD64
9222       print_vms_time (entry->d_un.d_val);
9223 #endif
9224       break;
9225
9226     case DT_IA_64_VMS_LNKFLAGS:
9227       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9228       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9229         printf (" CALL_DEBUG");
9230       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9231         printf (" NOP0BUFS");
9232       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9233         printf (" P0IMAGE");
9234       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9235         printf (" MKTHREADS");
9236       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9237         printf (" UPCALLS");
9238       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9239         printf (" IMGSTA");
9240       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9241         printf (" INITIALIZE");
9242       if (entry->d_un.d_val & VMS_LF_MAIN)
9243         printf (" MAIN");
9244       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9245         printf (" EXE_INIT");
9246       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9247         printf (" TBK_IN_IMG");
9248       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9249         printf (" DBG_IN_IMG");
9250       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9251         printf (" TBK_IN_DSF");
9252       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9253         printf (" DBG_IN_DSF");
9254       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9255         printf (" SIGNATURES");
9256       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9257         printf (" REL_SEG_OFF");
9258       break;
9259
9260     default:
9261       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9262       break;
9263     }
9264   putchar ('\n');
9265 }
9266
9267 static bfd_boolean
9268 get_32bit_dynamic_section (FILE * file)
9269 {
9270   Elf32_External_Dyn * edyn;
9271   Elf32_External_Dyn * ext;
9272   Elf_Internal_Dyn * entry;
9273
9274   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9275                                           dynamic_size, _("dynamic section"));
9276   if (!edyn)
9277     return FALSE;
9278
9279   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9280      might not have the luxury of section headers.  Look for the DT_NULL
9281      terminator to determine the number of entries.  */
9282   for (ext = edyn, dynamic_nent = 0;
9283        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9284        ext++)
9285     {
9286       dynamic_nent++;
9287       if (BYTE_GET (ext->d_tag) == DT_NULL)
9288         break;
9289     }
9290
9291   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9292                                                   sizeof (* entry));
9293   if (dynamic_section == NULL)
9294     {
9295       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9296              (unsigned long) dynamic_nent);
9297       free (edyn);
9298       return FALSE;
9299     }
9300
9301   for (ext = edyn, entry = dynamic_section;
9302        entry < dynamic_section + dynamic_nent;
9303        ext++, entry++)
9304     {
9305       entry->d_tag      = BYTE_GET (ext->d_tag);
9306       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9307     }
9308
9309   free (edyn);
9310
9311   return TRUE;
9312 }
9313
9314 static bfd_boolean
9315 get_64bit_dynamic_section (FILE * file)
9316 {
9317   Elf64_External_Dyn * edyn;
9318   Elf64_External_Dyn * ext;
9319   Elf_Internal_Dyn * entry;
9320
9321   /* Read in the data.  */
9322   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9323                                           dynamic_size, _("dynamic section"));
9324   if (!edyn)
9325     return FALSE;
9326
9327   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9328      might not have the luxury of section headers.  Look for the DT_NULL
9329      terminator to determine the number of entries.  */
9330   for (ext = edyn, dynamic_nent = 0;
9331        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9332        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9333        ext++)
9334     {
9335       dynamic_nent++;
9336       if (BYTE_GET (ext->d_tag) == DT_NULL)
9337         break;
9338     }
9339
9340   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9341                                                   sizeof (* entry));
9342   if (dynamic_section == NULL)
9343     {
9344       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9345              (unsigned long) dynamic_nent);
9346       free (edyn);
9347       return FALSE;
9348     }
9349
9350   /* Convert from external to internal formats.  */
9351   for (ext = edyn, entry = dynamic_section;
9352        entry < dynamic_section + dynamic_nent;
9353        ext++, entry++)
9354     {
9355       entry->d_tag      = BYTE_GET (ext->d_tag);
9356       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9357     }
9358
9359   free (edyn);
9360
9361   return TRUE;
9362 }
9363
9364 static void
9365 print_dynamic_flags (bfd_vma flags)
9366 {
9367   bfd_boolean first = TRUE;
9368
9369   while (flags)
9370     {
9371       bfd_vma flag;
9372
9373       flag = flags & - flags;
9374       flags &= ~ flag;
9375
9376       if (first)
9377         first = FALSE;
9378       else
9379         putc (' ', stdout);
9380
9381       switch (flag)
9382         {
9383         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9384         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9385         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9386         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9387         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9388         default:                fputs (_("unknown"), stdout); break;
9389         }
9390     }
9391   puts ("");
9392 }
9393
9394 /* Parse and display the contents of the dynamic section.  */
9395
9396 static bfd_boolean
9397 process_dynamic_section (FILE * file)
9398 {
9399   Elf_Internal_Dyn * entry;
9400
9401   if (dynamic_size == 0)
9402     {
9403       if (do_dynamic)
9404         printf (_("\nThere is no dynamic section in this file.\n"));
9405
9406       return TRUE;
9407     }
9408
9409   if (is_32bit_elf)
9410     {
9411       if (! get_32bit_dynamic_section (file))
9412         return FALSE;
9413     }
9414   else
9415     {
9416       if (! get_64bit_dynamic_section (file))
9417         return FALSE;
9418     }
9419
9420   /* Find the appropriate symbol table.  */
9421   if (dynamic_symbols == NULL)
9422     {
9423       for (entry = dynamic_section;
9424            entry < dynamic_section + dynamic_nent;
9425            ++entry)
9426         {
9427           Elf_Internal_Shdr section;
9428
9429           if (entry->d_tag != DT_SYMTAB)
9430             continue;
9431
9432           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9433
9434           /* Since we do not know how big the symbol table is,
9435              we default to reading in the entire file (!) and
9436              processing that.  This is overkill, I know, but it
9437              should work.  */
9438           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9439           if ((bfd_size_type) section.sh_offset > current_file_size)
9440             {
9441               /* See PR 21379 for a reproducer.  */
9442               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9443               return FALSE;
9444             }
9445
9446           if (archive_file_offset != 0)
9447             section.sh_size = archive_file_size - section.sh_offset;
9448           else
9449             {
9450               if (fseek (file, 0, SEEK_END))
9451                 error (_("Unable to seek to end of file!\n"));
9452
9453               section.sh_size = ftell (file) - section.sh_offset;
9454             }
9455
9456           if (is_32bit_elf)
9457             section.sh_entsize = sizeof (Elf32_External_Sym);
9458           else
9459             section.sh_entsize = sizeof (Elf64_External_Sym);
9460           section.sh_name = string_table_length;
9461
9462           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9463           if (num_dynamic_syms < 1)
9464             {
9465               error (_("Unable to determine the number of symbols to load\n"));
9466               continue;
9467             }
9468         }
9469     }
9470
9471   /* Similarly find a string table.  */
9472   if (dynamic_strings == NULL)
9473     {
9474       for (entry = dynamic_section;
9475            entry < dynamic_section + dynamic_nent;
9476            ++entry)
9477         {
9478           unsigned long offset;
9479           long str_tab_len;
9480
9481           if (entry->d_tag != DT_STRTAB)
9482             continue;
9483
9484           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9485
9486           /* Since we do not know how big the string table is,
9487              we default to reading in the entire file (!) and
9488              processing that.  This is overkill, I know, but it
9489              should work.  */
9490
9491           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9492
9493           if (archive_file_offset != 0)
9494             str_tab_len = archive_file_size - offset;
9495           else
9496             {
9497               if (fseek (file, 0, SEEK_END))
9498                 error (_("Unable to seek to end of file\n"));
9499               str_tab_len = ftell (file) - offset;
9500             }
9501
9502           if (str_tab_len < 1)
9503             {
9504               error
9505                 (_("Unable to determine the length of the dynamic string table\n"));
9506               continue;
9507             }
9508
9509           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9510                                                str_tab_len,
9511                                                _("dynamic string table"));
9512           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9513           break;
9514         }
9515     }
9516
9517   /* And find the syminfo section if available.  */
9518   if (dynamic_syminfo == NULL)
9519     {
9520       unsigned long syminsz = 0;
9521
9522       for (entry = dynamic_section;
9523            entry < dynamic_section + dynamic_nent;
9524            ++entry)
9525         {
9526           if (entry->d_tag == DT_SYMINENT)
9527             {
9528               /* Note: these braces are necessary to avoid a syntax
9529                  error from the SunOS4 C compiler.  */
9530               /* PR binutils/17531: A corrupt file can trigger this test.
9531                  So do not use an assert, instead generate an error message.  */
9532               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9533                 error (_("Bad value (%d) for SYMINENT entry\n"),
9534                        (int) entry->d_un.d_val);
9535             }
9536           else if (entry->d_tag == DT_SYMINSZ)
9537             syminsz = entry->d_un.d_val;
9538           else if (entry->d_tag == DT_SYMINFO)
9539             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9540                                                       syminsz);
9541         }
9542
9543       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9544         {
9545           Elf_External_Syminfo * extsyminfo;
9546           Elf_External_Syminfo * extsym;
9547           Elf_Internal_Syminfo * syminfo;
9548
9549           /* There is a syminfo section.  Read the data.  */
9550           extsyminfo = (Elf_External_Syminfo *)
9551               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9552                         _("symbol information"));
9553           if (!extsyminfo)
9554             return FALSE;
9555
9556           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9557           if (dynamic_syminfo == NULL)
9558             {
9559               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9560                      (unsigned long) syminsz);
9561               return FALSE;
9562             }
9563
9564           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9565           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9566                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9567                ++syminfo, ++extsym)
9568             {
9569               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9570               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9571             }
9572
9573           free (extsyminfo);
9574         }
9575     }
9576
9577   if (do_dynamic && dynamic_addr)
9578     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9579             dynamic_addr, (unsigned long) dynamic_nent);
9580   if (do_dynamic)
9581     printf (_("  Tag        Type                         Name/Value\n"));
9582
9583   for (entry = dynamic_section;
9584        entry < dynamic_section + dynamic_nent;
9585        entry++)
9586     {
9587       if (do_dynamic)
9588         {
9589           const char * dtype;
9590
9591           putchar (' ');
9592           print_vma (entry->d_tag, FULL_HEX);
9593           dtype = get_dynamic_type (entry->d_tag);
9594           printf (" (%s)%*s", dtype,
9595                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9596         }
9597
9598       switch (entry->d_tag)
9599         {
9600         case DT_FLAGS:
9601           if (do_dynamic)
9602             print_dynamic_flags (entry->d_un.d_val);
9603           break;
9604
9605         case DT_AUXILIARY:
9606         case DT_FILTER:
9607         case DT_CONFIG:
9608         case DT_DEPAUDIT:
9609         case DT_AUDIT:
9610           if (do_dynamic)
9611             {
9612               switch (entry->d_tag)
9613                 {
9614                 case DT_AUXILIARY:
9615                   printf (_("Auxiliary library"));
9616                   break;
9617
9618                 case DT_FILTER:
9619                   printf (_("Filter library"));
9620                   break;
9621
9622                 case DT_CONFIG:
9623                   printf (_("Configuration file"));
9624                   break;
9625
9626                 case DT_DEPAUDIT:
9627                   printf (_("Dependency audit library"));
9628                   break;
9629
9630                 case DT_AUDIT:
9631                   printf (_("Audit library"));
9632                   break;
9633                 }
9634
9635               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9636                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9637               else
9638                 {
9639                   printf (": ");
9640                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9641                   putchar ('\n');
9642                 }
9643             }
9644           break;
9645
9646         case DT_FEATURE:
9647           if (do_dynamic)
9648             {
9649               printf (_("Flags:"));
9650
9651               if (entry->d_un.d_val == 0)
9652                 printf (_(" None\n"));
9653               else
9654                 {
9655                   unsigned long int val = entry->d_un.d_val;
9656
9657                   if (val & DTF_1_PARINIT)
9658                     {
9659                       printf (" PARINIT");
9660                       val ^= DTF_1_PARINIT;
9661                     }
9662                   if (val & DTF_1_CONFEXP)
9663                     {
9664                       printf (" CONFEXP");
9665                       val ^= DTF_1_CONFEXP;
9666                     }
9667                   if (val != 0)
9668                     printf (" %lx", val);
9669                   puts ("");
9670                 }
9671             }
9672           break;
9673
9674         case DT_POSFLAG_1:
9675           if (do_dynamic)
9676             {
9677               printf (_("Flags:"));
9678
9679               if (entry->d_un.d_val == 0)
9680                 printf (_(" None\n"));
9681               else
9682                 {
9683                   unsigned long int val = entry->d_un.d_val;
9684
9685                   if (val & DF_P1_LAZYLOAD)
9686                     {
9687                       printf (" LAZYLOAD");
9688                       val ^= DF_P1_LAZYLOAD;
9689                     }
9690                   if (val & DF_P1_GROUPPERM)
9691                     {
9692                       printf (" GROUPPERM");
9693                       val ^= DF_P1_GROUPPERM;
9694                     }
9695                   if (val != 0)
9696                     printf (" %lx", val);
9697                   puts ("");
9698                 }
9699             }
9700           break;
9701
9702         case DT_FLAGS_1:
9703           if (do_dynamic)
9704             {
9705               printf (_("Flags:"));
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_1_NOW)
9713                     {
9714                       printf (" NOW");
9715                       val ^= DF_1_NOW;
9716                     }
9717                   if (val & DF_1_GLOBAL)
9718                     {
9719                       printf (" GLOBAL");
9720                       val ^= DF_1_GLOBAL;
9721                     }
9722                   if (val & DF_1_GROUP)
9723                     {
9724                       printf (" GROUP");
9725                       val ^= DF_1_GROUP;
9726                     }
9727                   if (val & DF_1_NODELETE)
9728                     {
9729                       printf (" NODELETE");
9730                       val ^= DF_1_NODELETE;
9731                     }
9732                   if (val & DF_1_LOADFLTR)
9733                     {
9734                       printf (" LOADFLTR");
9735                       val ^= DF_1_LOADFLTR;
9736                     }
9737                   if (val & DF_1_INITFIRST)
9738                     {
9739                       printf (" INITFIRST");
9740                       val ^= DF_1_INITFIRST;
9741                     }
9742                   if (val & DF_1_NOOPEN)
9743                     {
9744                       printf (" NOOPEN");
9745                       val ^= DF_1_NOOPEN;
9746                     }
9747                   if (val & DF_1_ORIGIN)
9748                     {
9749                       printf (" ORIGIN");
9750                       val ^= DF_1_ORIGIN;
9751                     }
9752                   if (val & DF_1_DIRECT)
9753                     {
9754                       printf (" DIRECT");
9755                       val ^= DF_1_DIRECT;
9756                     }
9757                   if (val & DF_1_TRANS)
9758                     {
9759                       printf (" TRANS");
9760                       val ^= DF_1_TRANS;
9761                     }
9762                   if (val & DF_1_INTERPOSE)
9763                     {
9764                       printf (" INTERPOSE");
9765                       val ^= DF_1_INTERPOSE;
9766                     }
9767                   if (val & DF_1_NODEFLIB)
9768                     {
9769                       printf (" NODEFLIB");
9770                       val ^= DF_1_NODEFLIB;
9771                     }
9772                   if (val & DF_1_NODUMP)
9773                     {
9774                       printf (" NODUMP");
9775                       val ^= DF_1_NODUMP;
9776                     }
9777                   if (val & DF_1_CONFALT)
9778                     {
9779                       printf (" CONFALT");
9780                       val ^= DF_1_CONFALT;
9781                     }
9782                   if (val & DF_1_ENDFILTEE)
9783                     {
9784                       printf (" ENDFILTEE");
9785                       val ^= DF_1_ENDFILTEE;
9786                     }
9787                   if (val & DF_1_DISPRELDNE)
9788                     {
9789                       printf (" DISPRELDNE");
9790                       val ^= DF_1_DISPRELDNE;
9791                     }
9792                   if (val & DF_1_DISPRELPND)
9793                     {
9794                       printf (" DISPRELPND");
9795                       val ^= DF_1_DISPRELPND;
9796                     }
9797                   if (val & DF_1_NODIRECT)
9798                     {
9799                       printf (" NODIRECT");
9800                       val ^= DF_1_NODIRECT;
9801                     }
9802                   if (val & DF_1_IGNMULDEF)
9803                     {
9804                       printf (" IGNMULDEF");
9805                       val ^= DF_1_IGNMULDEF;
9806                     }
9807                   if (val & DF_1_NOKSYMS)
9808                     {
9809                       printf (" NOKSYMS");
9810                       val ^= DF_1_NOKSYMS;
9811                     }
9812                   if (val & DF_1_NOHDR)
9813                     {
9814                       printf (" NOHDR");
9815                       val ^= DF_1_NOHDR;
9816                     }
9817                   if (val & DF_1_EDITED)
9818                     {
9819                       printf (" EDITED");
9820                       val ^= DF_1_EDITED;
9821                     }
9822                   if (val & DF_1_NORELOC)
9823                     {
9824                       printf (" NORELOC");
9825                       val ^= DF_1_NORELOC;
9826                     }
9827                   if (val & DF_1_SYMINTPOSE)
9828                     {
9829                       printf (" SYMINTPOSE");
9830                       val ^= DF_1_SYMINTPOSE;
9831                     }
9832                   if (val & DF_1_GLOBAUDIT)
9833                     {
9834                       printf (" GLOBAUDIT");
9835                       val ^= DF_1_GLOBAUDIT;
9836                     }
9837                   if (val & DF_1_SINGLETON)
9838                     {
9839                       printf (" SINGLETON");
9840                       val ^= DF_1_SINGLETON;
9841                     }
9842                   if (val & DF_1_STUB)
9843                     {
9844                       printf (" STUB");
9845                       val ^= DF_1_STUB;
9846                     }
9847                   if (val & DF_1_PIE)
9848                     {
9849                       printf (" PIE");
9850                       val ^= DF_1_PIE;
9851                     }
9852                   if (val != 0)
9853                     printf (" %lx", val);
9854                   puts ("");
9855                 }
9856             }
9857           break;
9858
9859         case DT_PLTREL:
9860           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9861           if (do_dynamic)
9862             puts (get_dynamic_type (entry->d_un.d_val));
9863           break;
9864
9865         case DT_NULL    :
9866         case DT_NEEDED  :
9867         case DT_PLTGOT  :
9868         case DT_HASH    :
9869         case DT_STRTAB  :
9870         case DT_SYMTAB  :
9871         case DT_RELA    :
9872         case DT_INIT    :
9873         case DT_FINI    :
9874         case DT_SONAME  :
9875         case DT_RPATH   :
9876         case DT_SYMBOLIC:
9877         case DT_REL     :
9878         case DT_DEBUG   :
9879         case DT_TEXTREL :
9880         case DT_JMPREL  :
9881         case DT_RUNPATH :
9882           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9883
9884           if (do_dynamic)
9885             {
9886               char * name;
9887
9888               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9889                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9890               else
9891                 name = NULL;
9892
9893               if (name)
9894                 {
9895                   switch (entry->d_tag)
9896                     {
9897                     case DT_NEEDED:
9898                       printf (_("Shared library: [%s]"), name);
9899
9900                       if (streq (name, program_interpreter))
9901                         printf (_(" program interpreter"));
9902                       break;
9903
9904                     case DT_SONAME:
9905                       printf (_("Library soname: [%s]"), name);
9906                       break;
9907
9908                     case DT_RPATH:
9909                       printf (_("Library rpath: [%s]"), name);
9910                       break;
9911
9912                     case DT_RUNPATH:
9913                       printf (_("Library runpath: [%s]"), name);
9914                       break;
9915
9916                     default:
9917                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9918                       break;
9919                     }
9920                 }
9921               else
9922                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9923
9924               putchar ('\n');
9925             }
9926           break;
9927
9928         case DT_PLTRELSZ:
9929         case DT_RELASZ  :
9930         case DT_STRSZ   :
9931         case DT_RELSZ   :
9932         case DT_RELAENT :
9933         case DT_SYMENT  :
9934         case DT_RELENT  :
9935           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9936           /* Fall through.  */
9937         case DT_PLTPADSZ:
9938         case DT_MOVEENT :
9939         case DT_MOVESZ  :
9940         case DT_INIT_ARRAYSZ:
9941         case DT_FINI_ARRAYSZ:
9942         case DT_GNU_CONFLICTSZ:
9943         case DT_GNU_LIBLISTSZ:
9944           if (do_dynamic)
9945             {
9946               print_vma (entry->d_un.d_val, UNSIGNED);
9947               printf (_(" (bytes)\n"));
9948             }
9949           break;
9950
9951         case DT_VERDEFNUM:
9952         case DT_VERNEEDNUM:
9953         case DT_RELACOUNT:
9954         case DT_RELCOUNT:
9955           if (do_dynamic)
9956             {
9957               print_vma (entry->d_un.d_val, UNSIGNED);
9958               putchar ('\n');
9959             }
9960           break;
9961
9962         case DT_SYMINSZ:
9963         case DT_SYMINENT:
9964         case DT_SYMINFO:
9965         case DT_USED:
9966         case DT_INIT_ARRAY:
9967         case DT_FINI_ARRAY:
9968           if (do_dynamic)
9969             {
9970               if (entry->d_tag == DT_USED
9971                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9972                 {
9973                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9974
9975                   if (*name)
9976                     {
9977                       printf (_("Not needed object: [%s]\n"), name);
9978                       break;
9979                     }
9980                 }
9981
9982               print_vma (entry->d_un.d_val, PREFIX_HEX);
9983               putchar ('\n');
9984             }
9985           break;
9986
9987         case DT_BIND_NOW:
9988           /* The value of this entry is ignored.  */
9989           if (do_dynamic)
9990             putchar ('\n');
9991           break;
9992
9993         case DT_GNU_PRELINKED:
9994           if (do_dynamic)
9995             {
9996               struct tm * tmp;
9997               time_t atime = entry->d_un.d_val;
9998
9999               tmp = gmtime (&atime);
10000               /* PR 17533 file: 041-1244816-0.004.  */
10001               if (tmp == NULL)
10002                 printf (_("<corrupt time val: %lx"),
10003                         (unsigned long) atime);
10004               else
10005                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10006                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10007                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10008
10009             }
10010           break;
10011
10012         case DT_GNU_HASH:
10013           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10014           if (do_dynamic)
10015             {
10016               print_vma (entry->d_un.d_val, PREFIX_HEX);
10017               putchar ('\n');
10018             }
10019           break;
10020
10021         default:
10022           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10023             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10024               entry->d_un.d_val;
10025
10026           if (do_dynamic)
10027             {
10028               switch (elf_header.e_machine)
10029                 {
10030                 case EM_MIPS:
10031                 case EM_MIPS_RS3_LE:
10032                   dynamic_section_mips_val (entry);
10033                   break;
10034                 case EM_PARISC:
10035                   dynamic_section_parisc_val (entry);
10036                   break;
10037                 case EM_IA_64:
10038                   dynamic_section_ia64_val (entry);
10039                   break;
10040                 default:
10041                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10042                   putchar ('\n');
10043                 }
10044             }
10045           break;
10046         }
10047     }
10048
10049   return TRUE;
10050 }
10051
10052 static char *
10053 get_ver_flags (unsigned int flags)
10054 {
10055   static char buff[32];
10056
10057   buff[0] = 0;
10058
10059   if (flags == 0)
10060     return _("none");
10061
10062   if (flags & VER_FLG_BASE)
10063     strcat (buff, "BASE");
10064
10065   if (flags & VER_FLG_WEAK)
10066     {
10067       if (flags & VER_FLG_BASE)
10068         strcat (buff, " | ");
10069
10070       strcat (buff, "WEAK");
10071     }
10072
10073   if (flags & VER_FLG_INFO)
10074     {
10075       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10076         strcat (buff, " | ");
10077
10078       strcat (buff, "INFO");
10079     }
10080
10081   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10082     {
10083       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10084         strcat (buff, " | ");
10085
10086       strcat (buff, _("<unknown>"));
10087     }
10088
10089   return buff;
10090 }
10091
10092 /* Display the contents of the version sections.  */
10093
10094 static bfd_boolean
10095 process_version_sections (FILE * file)
10096 {
10097   Elf_Internal_Shdr * section;
10098   unsigned i;
10099   bfd_boolean found = FALSE;
10100
10101   if (! do_version)
10102     return TRUE;
10103
10104   for (i = 0, section = section_headers;
10105        i < elf_header.e_shnum;
10106        i++, section++)
10107     {
10108       switch (section->sh_type)
10109         {
10110         case SHT_GNU_verdef:
10111           {
10112             Elf_External_Verdef * edefs;
10113             unsigned int idx;
10114             unsigned int cnt;
10115             unsigned int end;
10116             char * endbuf;
10117
10118             found = TRUE;
10119
10120             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10121                     printable_section_name (section),
10122                     section->sh_info);
10123
10124             printf (_("  Addr: 0x"));
10125             printf_vma (section->sh_addr);
10126             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10127                     (unsigned long) section->sh_offset, section->sh_link,
10128                     printable_section_name_from_index (section->sh_link));
10129
10130             edefs = (Elf_External_Verdef *)
10131                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10132                           _("version definition section"));
10133             if (!edefs)
10134               break;
10135             endbuf = (char *) edefs + section->sh_size;
10136
10137             /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2.  */
10138             end = (section->sh_info < section->sh_size
10139                    ? section->sh_info : section->sh_size);
10140             for (idx = cnt = 0; cnt < end; ++cnt)
10141               {
10142                 char * vstart;
10143                 Elf_External_Verdef * edef;
10144                 Elf_Internal_Verdef ent;
10145                 Elf_External_Verdaux * eaux;
10146                 Elf_Internal_Verdaux aux;
10147                 unsigned int isum;
10148                 int j;
10149
10150                 /* Check for very large indices.  */
10151                 if (idx > (size_t) (endbuf - (char *) edefs))
10152                   break;
10153
10154                 vstart = ((char *) edefs) + idx;
10155                 if (vstart + sizeof (*edef) > endbuf)
10156                   break;
10157
10158                 edef = (Elf_External_Verdef *) vstart;
10159
10160                 ent.vd_version = BYTE_GET (edef->vd_version);
10161                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10162                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10163                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10164                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10165                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10166                 ent.vd_next    = BYTE_GET (edef->vd_next);
10167
10168                 printf (_("  %#06x: Rev: %d  Flags: %s"),
10169                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10170
10171                 printf (_("  Index: %d  Cnt: %d  "),
10172                         ent.vd_ndx, ent.vd_cnt);
10173
10174                 /* Check for overflow.  */
10175                 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
10176                   break;
10177
10178                 vstart += ent.vd_aux;
10179
10180                 eaux = (Elf_External_Verdaux *) vstart;
10181
10182                 aux.vda_name = BYTE_GET (eaux->vda_name);
10183                 aux.vda_next = BYTE_GET (eaux->vda_next);
10184
10185                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10186                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10187                 else
10188                   printf (_("Name index: %ld\n"), aux.vda_name);
10189
10190                 isum = idx + ent.vd_aux;
10191
10192                 for (j = 1; j < ent.vd_cnt; j++)
10193                   {
10194                     /* Check for overflow.  */
10195                     if (aux.vda_next > (size_t) (endbuf - vstart))
10196                       break;
10197
10198                     isum   += aux.vda_next;
10199                     vstart += aux.vda_next;
10200
10201                     eaux = (Elf_External_Verdaux *) vstart;
10202                     if (vstart + sizeof (*eaux) > endbuf)
10203                       break;
10204
10205                     aux.vda_name = BYTE_GET (eaux->vda_name);
10206                     aux.vda_next = BYTE_GET (eaux->vda_next);
10207
10208                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10209                       printf (_("  %#06x: Parent %d: %s\n"),
10210                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10211                     else
10212                       printf (_("  %#06x: Parent %d, name index: %ld\n"),
10213                               isum, j, aux.vda_name);
10214                   }
10215
10216                 if (j < ent.vd_cnt)
10217                   printf (_("  Version def aux past end of section\n"));
10218
10219                 /* PR 17531:
10220                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10221                 if (idx + ent.vd_next < idx)
10222                   break;
10223
10224                 idx += ent.vd_next;
10225               }
10226
10227             if (cnt < section->sh_info)
10228               printf (_("  Version definition past end of section\n"));
10229
10230             free (edefs);
10231           }
10232           break;
10233
10234         case SHT_GNU_verneed:
10235           {
10236             Elf_External_Verneed * eneed;
10237             unsigned int idx;
10238             unsigned int cnt;
10239             char * endbuf;
10240
10241             found = TRUE;
10242
10243             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10244                     printable_section_name (section), section->sh_info);
10245
10246             printf (_(" Addr: 0x"));
10247             printf_vma (section->sh_addr);
10248             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10249                     (unsigned long) section->sh_offset, section->sh_link,
10250                     printable_section_name_from_index (section->sh_link));
10251
10252             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10253                                                        section->sh_offset, 1,
10254                                                        section->sh_size,
10255                                                        _("Version Needs section"));
10256             if (!eneed)
10257               break;
10258             endbuf = (char *) eneed + section->sh_size;
10259
10260             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10261               {
10262                 Elf_External_Verneed * entry;
10263                 Elf_Internal_Verneed ent;
10264                 unsigned int isum;
10265                 int j;
10266                 char * vstart;
10267
10268                 if (idx > (size_t) (endbuf - (char *) eneed))
10269                   break;
10270
10271                 vstart = ((char *) eneed) + idx;
10272                 if (vstart + sizeof (*entry) > endbuf)
10273                   break;
10274
10275                 entry = (Elf_External_Verneed *) vstart;
10276
10277                 ent.vn_version = BYTE_GET (entry->vn_version);
10278                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10279                 ent.vn_file    = BYTE_GET (entry->vn_file);
10280                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10281                 ent.vn_next    = BYTE_GET (entry->vn_next);
10282
10283                 printf (_("  %#06x: Version: %d"), idx, ent.vn_version);
10284
10285                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10286                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10287                 else
10288                   printf (_("  File: %lx"), ent.vn_file);
10289
10290                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10291
10292                 /* Check for overflow.  */
10293                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10294                   break;
10295                 vstart += ent.vn_aux;
10296
10297                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10298                   {
10299                     Elf_External_Vernaux * eaux;
10300                     Elf_Internal_Vernaux aux;
10301
10302                     if (vstart + sizeof (*eaux) > endbuf)
10303                       break;
10304                     eaux = (Elf_External_Vernaux *) vstart;
10305
10306                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10307                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10308                     aux.vna_other = BYTE_GET (eaux->vna_other);
10309                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10310                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10311
10312                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10313                       printf (_("  %#06x:   Name: %s"),
10314                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10315                     else
10316                       printf (_("  %#06x:   Name index: %lx"),
10317                               isum, aux.vna_name);
10318
10319                     printf (_("  Flags: %s  Version: %d\n"),
10320                             get_ver_flags (aux.vna_flags), aux.vna_other);
10321
10322                     /* Check for overflow.  */
10323                     if (aux.vna_next > (size_t) (endbuf - vstart)
10324                         || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10325                       {
10326                         warn (_("Invalid vna_next field of %lx\n"),
10327                               aux.vna_next);
10328                         j = ent.vn_cnt;
10329                         break;
10330                       }
10331                     isum   += aux.vna_next;
10332                     vstart += aux.vna_next;
10333                   }
10334
10335                 if (j < ent.vn_cnt)
10336                   warn (_("Missing Version Needs auxillary information\n"));
10337
10338                 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
10339                   {
10340                     warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10341                     cnt = section->sh_info;
10342                     break;
10343                   }
10344                 idx += ent.vn_next;
10345               }
10346
10347             if (cnt < section->sh_info)
10348               warn (_("Missing Version Needs information\n"));
10349
10350             free (eneed);
10351           }
10352           break;
10353
10354         case SHT_GNU_versym:
10355           {
10356             Elf_Internal_Shdr * link_section;
10357             size_t total;
10358             unsigned int cnt;
10359             unsigned char * edata;
10360             unsigned short * data;
10361             char * strtab;
10362             Elf_Internal_Sym * symbols;
10363             Elf_Internal_Shdr * string_sec;
10364             unsigned long num_syms;
10365             long off;
10366
10367             if (section->sh_link >= elf_header.e_shnum)
10368               break;
10369
10370             link_section = section_headers + section->sh_link;
10371             total = section->sh_size / sizeof (Elf_External_Versym);
10372
10373             if (link_section->sh_link >= elf_header.e_shnum)
10374               break;
10375
10376             found = TRUE;
10377
10378             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10379             if (symbols == NULL)
10380               break;
10381
10382             string_sec = section_headers + link_section->sh_link;
10383
10384             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10385                                         string_sec->sh_size,
10386                                         _("version string table"));
10387             if (!strtab)
10388               {
10389                 free (symbols);
10390                 break;
10391               }
10392
10393             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10394                     printable_section_name (section), (unsigned long) total);
10395
10396             printf (_(" Addr: "));
10397             printf_vma (section->sh_addr);
10398             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10399                     (unsigned long) section->sh_offset, section->sh_link,
10400                     printable_section_name (link_section));
10401
10402             off = offset_from_vma (file,
10403                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10404                                    total * sizeof (short));
10405             edata = (unsigned char *) get_data (NULL, file, off, total,
10406                                                 sizeof (short),
10407                                                 _("version symbol data"));
10408             if (!edata)
10409               {
10410                 free (strtab);
10411                 free (symbols);
10412                 break;
10413               }
10414
10415             data = (short unsigned int *) cmalloc (total, sizeof (short));
10416
10417             for (cnt = total; cnt --;)
10418               data[cnt] = byte_get (edata + cnt * sizeof (short),
10419                                     sizeof (short));
10420
10421             free (edata);
10422
10423             for (cnt = 0; cnt < total; cnt += 4)
10424               {
10425                 int j, nn;
10426                 char *name;
10427                 char *invalid = _("*invalid*");
10428
10429                 printf ("  %03x:", cnt);
10430
10431                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10432                   switch (data[cnt + j])
10433                     {
10434                     case 0:
10435                       fputs (_("   0 (*local*)    "), stdout);
10436                       break;
10437
10438                     case 1:
10439                       fputs (_("   1 (*global*)   "), stdout);
10440                       break;
10441
10442                     default:
10443                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10444                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10445
10446                       /* If this index value is greater than the size of the symbols
10447                          array, break to avoid an out-of-bounds read.  */
10448                       if ((unsigned long)(cnt + j) >= num_syms)
10449                         {
10450                           warn (_("invalid index into symbol array\n"));
10451                           break;
10452                         }
10453
10454                       name = NULL;
10455                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10456                         {
10457                           Elf_Internal_Verneed ivn;
10458                           unsigned long offset;
10459
10460                           offset = offset_from_vma
10461                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10462                              sizeof (Elf_External_Verneed));
10463
10464                           do
10465                             {
10466                               Elf_Internal_Vernaux ivna;
10467                               Elf_External_Verneed evn;
10468                               Elf_External_Vernaux evna;
10469                               unsigned long a_off;
10470
10471                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10472                                             _("version need")) == NULL)
10473                                 break;
10474
10475                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10476                               ivn.vn_next = BYTE_GET (evn.vn_next);
10477
10478                               a_off = offset + ivn.vn_aux;
10479
10480                               do
10481                                 {
10482                                   if (get_data (&evna, file, a_off, sizeof (evna),
10483                                                 1, _("version need aux (2)")) == NULL)
10484                                     {
10485                                       ivna.vna_next  = 0;
10486                                       ivna.vna_other = 0;
10487                                     }
10488                                   else
10489                                     {
10490                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10491                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10492                                     }
10493
10494                                   a_off += ivna.vna_next;
10495                                 }
10496                               while (ivna.vna_other != data[cnt + j]
10497                                      && ivna.vna_next != 0);
10498
10499                               if (ivna.vna_other == data[cnt + j])
10500                                 {
10501                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10502
10503                                   if (ivna.vna_name >= string_sec->sh_size)
10504                                     name = invalid;
10505                                   else
10506                                     name = strtab + ivna.vna_name;
10507                                   break;
10508                                 }
10509
10510                               offset += ivn.vn_next;
10511                             }
10512                           while (ivn.vn_next);
10513                         }
10514
10515                       if (data[cnt + j] != 0x8001
10516                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10517                         {
10518                           Elf_Internal_Verdef ivd;
10519                           Elf_External_Verdef evd;
10520                           unsigned long offset;
10521
10522                           offset = offset_from_vma
10523                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10524                              sizeof evd);
10525
10526                           do
10527                             {
10528                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10529                                             _("version def")) == NULL)
10530                                 {
10531                                   ivd.vd_next = 0;
10532                                   /* PR 17531: file: 046-1082287-0.004.  */
10533                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10534                                   break;
10535                                 }
10536                               else
10537                                 {
10538                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10539                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10540                                 }
10541
10542                               offset += ivd.vd_next;
10543                             }
10544                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10545                                  && ivd.vd_next != 0);
10546
10547                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10548                             {
10549                               Elf_External_Verdaux evda;
10550                               Elf_Internal_Verdaux ivda;
10551
10552                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10553
10554                               if (get_data (&evda, file,
10555                                             offset - ivd.vd_next + ivd.vd_aux,
10556                                             sizeof (evda), 1,
10557                                             _("version def aux")) == NULL)
10558                                 break;
10559
10560                               ivda.vda_name = BYTE_GET (evda.vda_name);
10561
10562                               if (ivda.vda_name >= string_sec->sh_size)
10563                                 name = invalid;
10564                               else if (name != NULL && name != invalid)
10565                                 name = _("*both*");
10566                               else
10567                                 name = strtab + ivda.vda_name;
10568                             }
10569                         }
10570                       if (name != NULL)
10571                         nn += printf ("(%s%-*s",
10572                                       name,
10573                                       12 - (int) strlen (name),
10574                                       ")");
10575
10576                       if (nn < 18)
10577                         printf ("%*c", 18 - nn, ' ');
10578                     }
10579
10580                 putchar ('\n');
10581               }
10582
10583             free (data);
10584             free (strtab);
10585             free (symbols);
10586           }
10587           break;
10588
10589         default:
10590           break;
10591         }
10592     }
10593
10594   if (! found)
10595     printf (_("\nNo version information found in this file.\n"));
10596
10597   return TRUE;
10598 }
10599
10600 static const char *
10601 get_symbol_binding (unsigned int binding)
10602 {
10603   static char buff[32];
10604
10605   switch (binding)
10606     {
10607     case STB_LOCAL:     return "LOCAL";
10608     case STB_GLOBAL:    return "GLOBAL";
10609     case STB_WEAK:      return "WEAK";
10610     default:
10611       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10612         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10613                   binding);
10614       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10615         {
10616           if (binding == STB_GNU_UNIQUE
10617               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10618                   /* GNU is still using the default value 0.  */
10619                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10620             return "UNIQUE";
10621           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10622         }
10623       else
10624         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10625       return buff;
10626     }
10627 }
10628
10629 static const char *
10630 get_symbol_type (unsigned int type)
10631 {
10632   static char buff[32];
10633
10634   switch (type)
10635     {
10636     case STT_NOTYPE:    return "NOTYPE";
10637     case STT_OBJECT:    return "OBJECT";
10638     case STT_FUNC:      return "FUNC";
10639     case STT_SECTION:   return "SECTION";
10640     case STT_FILE:      return "FILE";
10641     case STT_COMMON:    return "COMMON";
10642     case STT_TLS:       return "TLS";
10643     case STT_RELC:      return "RELC";
10644     case STT_SRELC:     return "SRELC";
10645     default:
10646       if (type >= STT_LOPROC && type <= STT_HIPROC)
10647         {
10648           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10649             return "THUMB_FUNC";
10650
10651           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10652             return "REGISTER";
10653
10654           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10655             return "PARISC_MILLI";
10656
10657           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10658         }
10659       else if (type >= STT_LOOS && type <= STT_HIOS)
10660         {
10661           if (elf_header.e_machine == EM_PARISC)
10662             {
10663               if (type == STT_HP_OPAQUE)
10664                 return "HP_OPAQUE";
10665               if (type == STT_HP_STUB)
10666                 return "HP_STUB";
10667             }
10668
10669           if (type == STT_GNU_IFUNC
10670               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10671                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10672                   /* GNU is still using the default value 0.  */
10673                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10674             return "IFUNC";
10675
10676           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10677         }
10678       else
10679         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10680       return buff;
10681     }
10682 }
10683
10684 static const char *
10685 get_symbol_visibility (unsigned int visibility)
10686 {
10687   switch (visibility)
10688     {
10689     case STV_DEFAULT:   return "DEFAULT";
10690     case STV_INTERNAL:  return "INTERNAL";
10691     case STV_HIDDEN:    return "HIDDEN";
10692     case STV_PROTECTED: return "PROTECTED";
10693     default:
10694       error (_("Unrecognized visibility value: %u"), visibility);
10695       return _("<unknown>");
10696     }
10697 }
10698
10699 static const char *
10700 get_solaris_symbol_visibility (unsigned int visibility)
10701 {
10702   switch (visibility)
10703     {
10704     case 4: return "EXPORTED";
10705     case 5: return "SINGLETON";
10706     case 6: return "ELIMINATE";
10707     default: return get_symbol_visibility (visibility);
10708     }
10709 }
10710
10711 static const char *
10712 get_mips_symbol_other (unsigned int other)
10713 {
10714   switch (other)
10715     {
10716     case STO_OPTIONAL:      return "OPTIONAL";
10717     case STO_MIPS_PLT:      return "MIPS PLT";
10718     case STO_MIPS_PIC:      return "MIPS PIC";
10719     case STO_MICROMIPS:     return "MICROMIPS";
10720     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10721     case STO_MIPS16:        return "MIPS16";
10722     default:                return NULL;
10723     }
10724 }
10725
10726 static const char *
10727 get_ia64_symbol_other (unsigned int other)
10728 {
10729   if (is_ia64_vms ())
10730     {
10731       static char res[32];
10732
10733       res[0] = 0;
10734
10735       /* Function types is for images and .STB files only.  */
10736       switch (elf_header.e_type)
10737         {
10738         case ET_DYN:
10739         case ET_EXEC:
10740           switch (VMS_ST_FUNC_TYPE (other))
10741             {
10742             case VMS_SFT_CODE_ADDR:
10743               strcat (res, " CA");
10744               break;
10745             case VMS_SFT_SYMV_IDX:
10746               strcat (res, " VEC");
10747               break;
10748             case VMS_SFT_FD:
10749               strcat (res, " FD");
10750               break;
10751             case VMS_SFT_RESERVE:
10752               strcat (res, " RSV");
10753               break;
10754             default:
10755               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10756                     VMS_ST_FUNC_TYPE (other));
10757               strcat (res, " <unknown>");
10758               break;
10759             }
10760           break;
10761         default:
10762           break;
10763         }
10764       switch (VMS_ST_LINKAGE (other))
10765         {
10766         case VMS_STL_IGNORE:
10767           strcat (res, " IGN");
10768           break;
10769         case VMS_STL_RESERVE:
10770           strcat (res, " RSV");
10771           break;
10772         case VMS_STL_STD:
10773           strcat (res, " STD");
10774           break;
10775         case VMS_STL_LNK:
10776           strcat (res, " LNK");
10777           break;
10778         default:
10779           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10780                 VMS_ST_LINKAGE (other));
10781           strcat (res, " <unknown>");
10782           break;
10783         }
10784
10785       if (res[0] != 0)
10786         return res + 1;
10787       else
10788         return res;
10789     }
10790   return NULL;
10791 }
10792
10793 static const char *
10794 get_ppc64_symbol_other (unsigned int other)
10795 {
10796   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10797     {
10798       static char buf[32];
10799       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10800                 PPC64_LOCAL_ENTRY_OFFSET (other));
10801       return buf;
10802     }
10803   return NULL;
10804 }
10805
10806 static const char *
10807 get_symbol_other (unsigned int other)
10808 {
10809   const char * result = NULL;
10810   static char buff [32];
10811
10812   if (other == 0)
10813     return "";
10814
10815   switch (elf_header.e_machine)
10816     {
10817     case EM_MIPS:
10818       result = get_mips_symbol_other (other);
10819       break;
10820     case EM_IA_64:
10821       result = get_ia64_symbol_other (other);
10822       break;
10823     case EM_PPC64:
10824       result = get_ppc64_symbol_other (other);
10825       break;
10826     default:
10827       result = NULL;
10828       break;
10829     }
10830
10831   if (result)
10832     return result;
10833
10834   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10835   return buff;
10836 }
10837
10838 static const char *
10839 get_symbol_index_type (unsigned int type)
10840 {
10841   static char buff[32];
10842
10843   switch (type)
10844     {
10845     case SHN_UNDEF:     return "UND";
10846     case SHN_ABS:       return "ABS";
10847     case SHN_COMMON:    return "COM";
10848     default:
10849       if (type == SHN_IA_64_ANSI_COMMON
10850           && elf_header.e_machine == EM_IA_64
10851           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10852         return "ANSI_COM";
10853       else if ((elf_header.e_machine == EM_X86_64
10854                 || elf_header.e_machine == EM_L1OM
10855                 || elf_header.e_machine == EM_K1OM)
10856                && type == SHN_X86_64_LCOMMON)
10857         return "LARGE_COM";
10858       else if ((type == SHN_MIPS_SCOMMON
10859                 && elf_header.e_machine == EM_MIPS)
10860                || (type == SHN_TIC6X_SCOMMON
10861                    && elf_header.e_machine == EM_TI_C6000))
10862         return "SCOM";
10863       else if (type == SHN_MIPS_SUNDEFINED
10864                && elf_header.e_machine == EM_MIPS)
10865         return "SUND";
10866       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10867         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10868       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10869         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10870       else if (type >= SHN_LORESERVE)
10871         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10872       else if (type >= elf_header.e_shnum)
10873         sprintf (buff, _("bad section index[%3d]"), type);
10874       else
10875         sprintf (buff, "%3d", type);
10876       break;
10877     }
10878
10879   return buff;
10880 }
10881
10882 static bfd_vma *
10883 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10884 {
10885   unsigned char * e_data;
10886   bfd_vma * i_data;
10887
10888   /* If the size_t type is smaller than the bfd_size_type, eg because
10889      you are building a 32-bit tool on a 64-bit host, then make sure
10890      that when (number) is cast to (size_t) no information is lost.  */
10891   if (sizeof (size_t) < sizeof (bfd_size_type)
10892       && (bfd_size_type) ((size_t) number) != number)
10893     {
10894       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10895                " elements of size %u\n"),
10896              number, ent_size);
10897       return NULL;
10898     }
10899
10900   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10901      attempting to allocate memory when the read is bound to fail.  */
10902   if (ent_size * number > current_file_size)
10903     {
10904       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10905              number);
10906       return NULL;
10907     }
10908
10909   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10910   if (e_data == NULL)
10911     {
10912       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10913              number);
10914       return NULL;
10915     }
10916
10917   if (fread (e_data, ent_size, (size_t) number, file) != number)
10918     {
10919       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10920              number * ent_size);
10921       free (e_data);
10922       return NULL;
10923     }
10924
10925   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10926   if (i_data == NULL)
10927     {
10928       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10929                " dynamic entries\n"),
10930              number);
10931       free (e_data);
10932       return NULL;
10933     }
10934
10935   while (number--)
10936     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10937
10938   free (e_data);
10939
10940   return i_data;
10941 }
10942
10943 static void
10944 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10945 {
10946   Elf_Internal_Sym * psym;
10947   int n;
10948
10949   n = print_vma (si, DEC_5);
10950   if (n < 5)
10951     fputs (&"     "[n], stdout);
10952   printf (" %3lu: ", hn);
10953
10954   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10955     {
10956       printf (_("<No info available for dynamic symbol number %lu>\n"),
10957               (unsigned long) si);
10958       return;
10959     }
10960
10961   psym = dynamic_symbols + si;
10962   print_vma (psym->st_value, LONG_HEX);
10963   putchar (' ');
10964   print_vma (psym->st_size, DEC_5);
10965
10966   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10967   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10968
10969   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10970     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
10971   else
10972     {
10973       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10974
10975       printf (" %-7s",  get_symbol_visibility (vis));
10976       /* Check to see if any other bits in the st_other field are set.
10977          Note - displaying this information disrupts the layout of the
10978          table being generated, but for the moment this case is very
10979          rare.  */
10980       if (psym->st_other ^ vis)
10981         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10982     }
10983
10984   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10985   if (VALID_DYNAMIC_NAME (psym->st_name))
10986     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10987   else
10988     printf (_(" <corrupt: %14ld>"), psym->st_name);
10989   putchar ('\n');
10990 }
10991
10992 static const char *
10993 get_symbol_version_string (FILE *                       file,
10994                            bfd_boolean                  is_dynsym,
10995                            const char *                 strtab,
10996                            unsigned long int            strtab_size,
10997                            unsigned int                 si,
10998                            Elf_Internal_Sym *           psym,
10999                            enum versioned_symbol_info * sym_info,
11000                            unsigned short *             vna_other)
11001 {
11002   unsigned char data[2];
11003   unsigned short vers_data;
11004   unsigned long offset;
11005
11006   if (!is_dynsym
11007       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11008     return NULL;
11009
11010   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11011                             sizeof data + si * sizeof (vers_data));
11012
11013   if (get_data (&data, file, offset + si * sizeof (vers_data),
11014                 sizeof (data), 1, _("version data")) == NULL)
11015     return NULL;
11016
11017   vers_data = byte_get (data, 2);
11018
11019   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11020     return NULL;
11021
11022   /* Usually we'd only see verdef for defined symbols, and verneed for
11023      undefined symbols.  However, symbols defined by the linker in
11024      .dynbss for variables copied from a shared library in order to
11025      avoid text relocations are defined yet have verneed.  We could
11026      use a heuristic to detect the special case, for example, check
11027      for verneed first on symbols defined in SHT_NOBITS sections, but
11028      it is simpler and more reliable to just look for both verdef and
11029      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11030
11031   if (psym->st_shndx != SHN_UNDEF
11032       && vers_data != 0x8001
11033       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11034     {
11035       Elf_Internal_Verdef ivd;
11036       Elf_Internal_Verdaux ivda;
11037       Elf_External_Verdaux evda;
11038       unsigned long off;
11039
11040       off = offset_from_vma (file,
11041                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11042                              sizeof (Elf_External_Verdef));
11043
11044       do
11045         {
11046           Elf_External_Verdef evd;
11047
11048           if (get_data (&evd, file, off, sizeof (evd), 1,
11049                         _("version def")) == NULL)
11050             {
11051               ivd.vd_ndx = 0;
11052               ivd.vd_aux = 0;
11053               ivd.vd_next = 0;
11054             }
11055           else
11056             {
11057               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11058               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11059               ivd.vd_next = BYTE_GET (evd.vd_next);
11060             }
11061
11062           off += ivd.vd_next;
11063         }
11064       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11065
11066       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11067         {
11068           off -= ivd.vd_next;
11069           off += ivd.vd_aux;
11070
11071           if (get_data (&evda, file, off, sizeof (evda), 1,
11072                         _("version def aux")) != NULL)
11073             {
11074               ivda.vda_name = BYTE_GET (evda.vda_name);
11075
11076               if (psym->st_name != ivda.vda_name)
11077                 {
11078                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11079                                ? symbol_hidden : symbol_public);
11080                   return (ivda.vda_name < strtab_size
11081                           ? strtab + ivda.vda_name : _("<corrupt>"));
11082                 }
11083             }
11084         }
11085     }
11086
11087   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11088     {
11089       Elf_External_Verneed evn;
11090       Elf_Internal_Verneed ivn;
11091       Elf_Internal_Vernaux ivna;
11092
11093       offset = offset_from_vma (file,
11094                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11095                                 sizeof evn);
11096       do
11097         {
11098           unsigned long vna_off;
11099
11100           if (get_data (&evn, file, offset, sizeof (evn), 1,
11101                         _("version need")) == NULL)
11102             {
11103               ivna.vna_next = 0;
11104               ivna.vna_other = 0;
11105               ivna.vna_name = 0;
11106               break;
11107             }
11108
11109           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11110           ivn.vn_next = BYTE_GET (evn.vn_next);
11111
11112           vna_off = offset + ivn.vn_aux;
11113
11114           do
11115             {
11116               Elf_External_Vernaux evna;
11117
11118               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11119                             _("version need aux (3)")) == NULL)
11120                 {
11121                   ivna.vna_next = 0;
11122                   ivna.vna_other = 0;
11123                   ivna.vna_name = 0;
11124                 }
11125               else
11126                 {
11127                   ivna.vna_other = BYTE_GET (evna.vna_other);
11128                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11129                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11130                 }
11131
11132               vna_off += ivna.vna_next;
11133             }
11134           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11135
11136           if (ivna.vna_other == vers_data)
11137             break;
11138
11139           offset += ivn.vn_next;
11140         }
11141       while (ivn.vn_next != 0);
11142
11143       if (ivna.vna_other == vers_data)
11144         {
11145           *sym_info = symbol_undefined;
11146           *vna_other = ivna.vna_other;
11147           return (ivna.vna_name < strtab_size
11148                   ? strtab + ivna.vna_name : _("<corrupt>"));
11149         }
11150     }
11151   return NULL;
11152 }
11153
11154 /* Dump the symbol table.  */
11155 static bfd_boolean
11156 process_symbol_table (FILE * file)
11157 {
11158   Elf_Internal_Shdr * section;
11159   bfd_size_type nbuckets = 0;
11160   bfd_size_type nchains = 0;
11161   bfd_vma * buckets = NULL;
11162   bfd_vma * chains = NULL;
11163   bfd_vma ngnubuckets = 0;
11164   bfd_vma * gnubuckets = NULL;
11165   bfd_vma * gnuchains = NULL;
11166   bfd_vma gnusymidx = 0;
11167   bfd_size_type ngnuchains = 0;
11168
11169   if (!do_syms && !do_dyn_syms && !do_histogram)
11170     return TRUE;
11171
11172   if (dynamic_info[DT_HASH]
11173       && (do_histogram
11174           || (do_using_dynamic
11175               && !do_dyn_syms
11176               && dynamic_strings != NULL)))
11177     {
11178       unsigned char nb[8];
11179       unsigned char nc[8];
11180       unsigned int hash_ent_size = 4;
11181
11182       if ((elf_header.e_machine == EM_ALPHA
11183            || elf_header.e_machine == EM_S390
11184            || elf_header.e_machine == EM_S390_OLD)
11185           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11186         hash_ent_size = 8;
11187
11188       if (fseek (file,
11189                  (archive_file_offset
11190                   + offset_from_vma (file, dynamic_info[DT_HASH],
11191                                      sizeof nb + sizeof nc)),
11192                  SEEK_SET))
11193         {
11194           error (_("Unable to seek to start of dynamic information\n"));
11195           goto no_hash;
11196         }
11197
11198       if (fread (nb, hash_ent_size, 1, file) != 1)
11199         {
11200           error (_("Failed to read in number of buckets\n"));
11201           goto no_hash;
11202         }
11203
11204       if (fread (nc, hash_ent_size, 1, file) != 1)
11205         {
11206           error (_("Failed to read in number of chains\n"));
11207           goto no_hash;
11208         }
11209
11210       nbuckets = byte_get (nb, hash_ent_size);
11211       nchains  = byte_get (nc, hash_ent_size);
11212
11213       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11214       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11215
11216     no_hash:
11217       if (buckets == NULL || chains == NULL)
11218         {
11219           if (do_using_dynamic)
11220             return FALSE;
11221           free (buckets);
11222           free (chains);
11223           buckets = NULL;
11224           chains = NULL;
11225           nbuckets = 0;
11226           nchains = 0;
11227         }
11228     }
11229
11230   if (dynamic_info_DT_GNU_HASH
11231       && (do_histogram
11232           || (do_using_dynamic
11233               && !do_dyn_syms
11234               && dynamic_strings != NULL)))
11235     {
11236       unsigned char nb[16];
11237       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11238       bfd_vma buckets_vma;
11239
11240       if (fseek (file,
11241                  (archive_file_offset
11242                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11243                                      sizeof nb)),
11244                  SEEK_SET))
11245         {
11246           error (_("Unable to seek to start of dynamic information\n"));
11247           goto no_gnu_hash;
11248         }
11249
11250       if (fread (nb, 16, 1, file) != 1)
11251         {
11252           error (_("Failed to read in number of buckets\n"));
11253           goto no_gnu_hash;
11254         }
11255
11256       ngnubuckets = byte_get (nb, 4);
11257       gnusymidx = byte_get (nb + 4, 4);
11258       bitmaskwords = byte_get (nb + 8, 4);
11259       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11260       if (is_32bit_elf)
11261         buckets_vma += bitmaskwords * 4;
11262       else
11263         buckets_vma += bitmaskwords * 8;
11264
11265       if (fseek (file,
11266                  (archive_file_offset
11267                   + offset_from_vma (file, buckets_vma, 4)),
11268                  SEEK_SET))
11269         {
11270           error (_("Unable to seek to start of dynamic information\n"));
11271           goto no_gnu_hash;
11272         }
11273
11274       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11275
11276       if (gnubuckets == NULL)
11277         goto no_gnu_hash;
11278
11279       for (i = 0; i < ngnubuckets; i++)
11280         if (gnubuckets[i] != 0)
11281           {
11282             if (gnubuckets[i] < gnusymidx)
11283               return FALSE;
11284
11285             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11286               maxchain = gnubuckets[i];
11287           }
11288
11289       if (maxchain == 0xffffffff)
11290         goto no_gnu_hash;
11291
11292       maxchain -= gnusymidx;
11293
11294       if (fseek (file,
11295                  (archive_file_offset
11296                   + offset_from_vma (file, buckets_vma
11297                                            + 4 * (ngnubuckets + maxchain), 4)),
11298                  SEEK_SET))
11299         {
11300           error (_("Unable to seek to start of dynamic information\n"));
11301           goto no_gnu_hash;
11302         }
11303
11304       do
11305         {
11306           if (fread (nb, 4, 1, file) != 1)
11307             {
11308               error (_("Failed to determine last chain length\n"));
11309               goto no_gnu_hash;
11310             }
11311
11312           if (maxchain + 1 == 0)
11313             goto no_gnu_hash;
11314
11315           ++maxchain;
11316         }
11317       while ((byte_get (nb, 4) & 1) == 0);
11318
11319       if (fseek (file,
11320                  (archive_file_offset
11321                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11322                  SEEK_SET))
11323         {
11324           error (_("Unable to seek to start of dynamic information\n"));
11325           goto no_gnu_hash;
11326         }
11327
11328       gnuchains = get_dynamic_data (file, maxchain, 4);
11329       ngnuchains = maxchain;
11330
11331     no_gnu_hash:
11332       if (gnuchains == NULL)
11333         {
11334           free (gnubuckets);
11335           gnubuckets = NULL;
11336           ngnubuckets = 0;
11337           if (do_using_dynamic)
11338             return FALSE;
11339         }
11340     }
11341
11342   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11343       && do_syms
11344       && do_using_dynamic
11345       && dynamic_strings != NULL
11346       && dynamic_symbols != NULL)
11347     {
11348       unsigned long hn;
11349
11350       if (dynamic_info[DT_HASH])
11351         {
11352           bfd_vma si;
11353
11354           printf (_("\nSymbol table for image:\n"));
11355           if (is_32bit_elf)
11356             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11357           else
11358             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11359
11360           for (hn = 0; hn < nbuckets; hn++)
11361             {
11362               if (! buckets[hn])
11363                 continue;
11364
11365               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11366                 print_dynamic_symbol (si, hn);
11367             }
11368         }
11369
11370       if (dynamic_info_DT_GNU_HASH)
11371         {
11372           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11373           if (is_32bit_elf)
11374             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11375           else
11376             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11377
11378           for (hn = 0; hn < ngnubuckets; ++hn)
11379             if (gnubuckets[hn] != 0)
11380               {
11381                 bfd_vma si = gnubuckets[hn];
11382                 bfd_vma off = si - gnusymidx;
11383
11384                 do
11385                   {
11386                     print_dynamic_symbol (si, hn);
11387                     si++;
11388                   }
11389                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11390               }
11391         }
11392     }
11393   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11394            && section_headers != NULL)
11395     {
11396       unsigned int i;
11397
11398       for (i = 0, section = section_headers;
11399            i < elf_header.e_shnum;
11400            i++, section++)
11401         {
11402           unsigned int si;
11403           char * strtab = NULL;
11404           unsigned long int strtab_size = 0;
11405           Elf_Internal_Sym * symtab;
11406           Elf_Internal_Sym * psym;
11407           unsigned long num_syms;
11408
11409           if ((section->sh_type != SHT_SYMTAB
11410                && section->sh_type != SHT_DYNSYM)
11411               || (!do_syms
11412                   && section->sh_type == SHT_SYMTAB))
11413             continue;
11414
11415           if (section->sh_entsize == 0)
11416             {
11417               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11418                       printable_section_name (section));
11419               continue;
11420             }
11421
11422           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11423                   printable_section_name (section),
11424                   (unsigned long) (section->sh_size / section->sh_entsize));
11425
11426           if (is_32bit_elf)
11427             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11428           else
11429             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11430
11431           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11432           if (symtab == NULL)
11433             continue;
11434
11435           if (section->sh_link == elf_header.e_shstrndx)
11436             {
11437               strtab = string_table;
11438               strtab_size = string_table_length;
11439             }
11440           else if (section->sh_link < elf_header.e_shnum)
11441             {
11442               Elf_Internal_Shdr * string_sec;
11443
11444               string_sec = section_headers + section->sh_link;
11445
11446               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11447                                           1, string_sec->sh_size,
11448                                           _("string table"));
11449               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11450             }
11451
11452           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11453             {
11454               const char *version_string;
11455               enum versioned_symbol_info sym_info;
11456               unsigned short vna_other;
11457
11458               printf ("%6d: ", si);
11459               print_vma (psym->st_value, LONG_HEX);
11460               putchar (' ');
11461               print_vma (psym->st_size, DEC_5);
11462               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11463               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11464               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11465                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11466               else
11467                 {
11468                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11469
11470                   printf (" %-7s", get_symbol_visibility (vis));
11471                   /* Check to see if any other bits in the st_other field are set.
11472                      Note - displaying this information disrupts the layout of the
11473                      table being generated, but for the moment this case is very rare.  */
11474                   if (psym->st_other ^ vis)
11475                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11476                 }
11477               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11478               print_symbol (25, psym->st_name < strtab_size
11479                             ? strtab + psym->st_name : _("<corrupt>"));
11480
11481               version_string
11482                 = get_symbol_version_string (file,
11483                                              section->sh_type == SHT_DYNSYM,
11484                                              strtab, strtab_size, si,
11485                                              psym, &sym_info, &vna_other);
11486               if (version_string)
11487                 {
11488                   if (sym_info == symbol_undefined)
11489                     printf ("@%s (%d)", version_string, vna_other);
11490                   else
11491                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11492                             version_string);
11493                 }
11494
11495               putchar ('\n');
11496
11497               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11498                   && si >= section->sh_info
11499                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11500                   && elf_header.e_machine != EM_MIPS
11501                   /* Solaris binaries have been found to violate this requirement as
11502                      well.  Not sure if this is a bug or an ABI requirement.  */
11503                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11504                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11505                       si, printable_section_name (section), section->sh_info);
11506             }
11507
11508           free (symtab);
11509           if (strtab != string_table)
11510             free (strtab);
11511         }
11512     }
11513   else if (do_syms)
11514     printf
11515       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11516
11517   if (do_histogram && buckets != NULL)
11518     {
11519       unsigned long * lengths;
11520       unsigned long * counts;
11521       unsigned long hn;
11522       bfd_vma si;
11523       unsigned long maxlength = 0;
11524       unsigned long nzero_counts = 0;
11525       unsigned long nsyms = 0;
11526       unsigned long chained;
11527
11528       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11529               (unsigned long) nbuckets);
11530
11531       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11532       if (lengths == NULL)
11533         {
11534           error (_("Out of memory allocating space for histogram buckets\n"));
11535           return FALSE;
11536         }
11537
11538       printf (_(" Length  Number     %% of total  Coverage\n"));
11539       for (hn = 0; hn < nbuckets; ++hn)
11540         {
11541           for (si = buckets[hn], chained = 0;
11542                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11543                si = chains[si], ++chained)
11544             {
11545               ++nsyms;
11546               if (maxlength < ++lengths[hn])
11547                 ++maxlength;
11548             }
11549
11550             /* PR binutils/17531: A corrupt binary could contain broken
11551                histogram data.  Do not go into an infinite loop trying
11552                to process it.  */
11553             if (chained > nchains)
11554               {
11555                 error (_("histogram chain is corrupt\n"));
11556                 break;
11557               }
11558         }
11559
11560       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11561       if (counts == NULL)
11562         {
11563           free (lengths);
11564           error (_("Out of memory allocating space for histogram counts\n"));
11565           return FALSE;
11566         }
11567
11568       for (hn = 0; hn < nbuckets; ++hn)
11569         ++counts[lengths[hn]];
11570
11571       if (nbuckets > 0)
11572         {
11573           unsigned long i;
11574           printf ("      0  %-10lu (%5.1f%%)\n",
11575                   counts[0], (counts[0] * 100.0) / nbuckets);
11576           for (i = 1; i <= maxlength; ++i)
11577             {
11578               nzero_counts += counts[i] * i;
11579               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11580                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11581                       (nzero_counts * 100.0) / nsyms);
11582             }
11583         }
11584
11585       free (counts);
11586       free (lengths);
11587     }
11588
11589   if (buckets != NULL)
11590     {
11591       free (buckets);
11592       free (chains);
11593     }
11594
11595   if (do_histogram && gnubuckets != NULL)
11596     {
11597       unsigned long * lengths;
11598       unsigned long * counts;
11599       unsigned long hn;
11600       unsigned long maxlength = 0;
11601       unsigned long nzero_counts = 0;
11602       unsigned long nsyms = 0;
11603
11604       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11605               (unsigned long) ngnubuckets);
11606
11607       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11608       if (lengths == NULL)
11609         {
11610           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11611           return FALSE;
11612         }
11613
11614       printf (_(" Length  Number     %% of total  Coverage\n"));
11615
11616       for (hn = 0; hn < ngnubuckets; ++hn)
11617         if (gnubuckets[hn] != 0)
11618           {
11619             bfd_vma off, length = 1;
11620
11621             for (off = gnubuckets[hn] - gnusymidx;
11622                  /* PR 17531 file: 010-77222-0.004.  */
11623                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11624                  ++off)
11625               ++length;
11626             lengths[hn] = length;
11627             if (length > maxlength)
11628               maxlength = length;
11629             nsyms += length;
11630           }
11631
11632       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11633       if (counts == NULL)
11634         {
11635           free (lengths);
11636           error (_("Out of memory allocating space for gnu histogram counts\n"));
11637           return FALSE;
11638         }
11639
11640       for (hn = 0; hn < ngnubuckets; ++hn)
11641         ++counts[lengths[hn]];
11642
11643       if (ngnubuckets > 0)
11644         {
11645           unsigned long j;
11646           printf ("      0  %-10lu (%5.1f%%)\n",
11647                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11648           for (j = 1; j <= maxlength; ++j)
11649             {
11650               nzero_counts += counts[j] * j;
11651               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11652                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11653                       (nzero_counts * 100.0) / nsyms);
11654             }
11655         }
11656
11657       free (counts);
11658       free (lengths);
11659       free (gnubuckets);
11660       free (gnuchains);
11661     }
11662
11663   return TRUE;
11664 }
11665
11666 static bfd_boolean
11667 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11668 {
11669   unsigned int i;
11670
11671   if (dynamic_syminfo == NULL
11672       || !do_dynamic)
11673     /* No syminfo, this is ok.  */
11674     return TRUE;
11675
11676   /* There better should be a dynamic symbol section.  */
11677   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11678     return FALSE;
11679
11680   if (dynamic_addr)
11681     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11682             dynamic_syminfo_offset, dynamic_syminfo_nent);
11683
11684   printf (_(" Num: Name                           BoundTo     Flags\n"));
11685   for (i = 0; i < dynamic_syminfo_nent; ++i)
11686     {
11687       unsigned short int flags = dynamic_syminfo[i].si_flags;
11688
11689       printf ("%4d: ", i);
11690       if (i >= num_dynamic_syms)
11691         printf (_("<corrupt index>"));
11692       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11693         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11694       else
11695         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11696       putchar (' ');
11697
11698       switch (dynamic_syminfo[i].si_boundto)
11699         {
11700         case SYMINFO_BT_SELF:
11701           fputs ("SELF       ", stdout);
11702           break;
11703         case SYMINFO_BT_PARENT:
11704           fputs ("PARENT     ", stdout);
11705           break;
11706         default:
11707           if (dynamic_syminfo[i].si_boundto > 0
11708               && dynamic_syminfo[i].si_boundto < dynamic_nent
11709               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11710             {
11711               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11712               putchar (' ' );
11713             }
11714           else
11715             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11716           break;
11717         }
11718
11719       if (flags & SYMINFO_FLG_DIRECT)
11720         printf (" DIRECT");
11721       if (flags & SYMINFO_FLG_PASSTHRU)
11722         printf (" PASSTHRU");
11723       if (flags & SYMINFO_FLG_COPY)
11724         printf (" COPY");
11725       if (flags & SYMINFO_FLG_LAZYLOAD)
11726         printf (" LAZYLOAD");
11727
11728       puts ("");
11729     }
11730
11731   return TRUE;
11732 }
11733
11734 #define IN_RANGE(START,END,ADDR,OFF)            \
11735   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11736
11737 /* Check to see if the given reloc needs to be handled in a target specific
11738    manner.  If so then process the reloc and return TRUE otherwise return
11739    FALSE.
11740
11741    If called with reloc == NULL, then this is a signal that reloc processing
11742    for the current section has finished, and any saved state should be
11743    discarded.  */
11744
11745 static bfd_boolean
11746 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11747                                 unsigned char *     start,
11748                                 unsigned char *     end,
11749                                 Elf_Internal_Sym *  symtab,
11750                                 unsigned long       num_syms)
11751 {
11752   unsigned int reloc_type = 0;
11753   unsigned long sym_index = 0;
11754
11755   if (reloc)
11756     {
11757       reloc_type = get_reloc_type (reloc->r_info);
11758       sym_index = get_reloc_symindex (reloc->r_info);
11759     }
11760
11761   switch (elf_header.e_machine)
11762     {
11763     case EM_MSP430:
11764     case EM_MSP430_OLD:
11765       {
11766         static Elf_Internal_Sym * saved_sym = NULL;
11767
11768         if (reloc == NULL)
11769           {
11770             saved_sym = NULL;
11771             return TRUE;
11772           }
11773
11774         switch (reloc_type)
11775           {
11776           case 10: /* R_MSP430_SYM_DIFF */
11777             if (uses_msp430x_relocs ())
11778               break;
11779             /* Fall through.  */
11780           case 21: /* R_MSP430X_SYM_DIFF */
11781             /* PR 21139.  */
11782             if (sym_index >= num_syms)
11783               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11784                      sym_index);
11785             else
11786               saved_sym = symtab + sym_index;
11787             return TRUE;
11788
11789           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11790           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11791             goto handle_sym_diff;
11792
11793           case 5: /* R_MSP430_16_BYTE */
11794           case 9: /* R_MSP430_8 */
11795             if (uses_msp430x_relocs ())
11796               break;
11797             goto handle_sym_diff;
11798
11799           case 2: /* R_MSP430_ABS16 */
11800           case 15: /* R_MSP430X_ABS16 */
11801             if (! uses_msp430x_relocs ())
11802               break;
11803             goto handle_sym_diff;
11804
11805           handle_sym_diff:
11806             if (saved_sym != NULL)
11807               {
11808                 int reloc_size = reloc_type == 1 ? 4 : 2;
11809                 bfd_vma value;
11810
11811                 if (sym_index >= num_syms)
11812                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11813                          sym_index);
11814                 else
11815                   {
11816                     value = reloc->r_addend + (symtab[sym_index].st_value
11817                                                - saved_sym->st_value);
11818
11819                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11820                       byte_put (start + reloc->r_offset, value, reloc_size);
11821                     else
11822                       /* PR 21137 */
11823                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11824                              (long) reloc->r_offset);
11825                   }
11826
11827                 saved_sym = NULL;
11828                 return TRUE;
11829               }
11830             break;
11831
11832           default:
11833             if (saved_sym != NULL)
11834               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11835             break;
11836           }
11837         break;
11838       }
11839
11840     case EM_MN10300:
11841     case EM_CYGNUS_MN10300:
11842       {
11843         static Elf_Internal_Sym * saved_sym = NULL;
11844
11845         if (reloc == NULL)
11846           {
11847             saved_sym = NULL;
11848             return TRUE;
11849           }
11850
11851         switch (reloc_type)
11852           {
11853           case 34: /* R_MN10300_ALIGN */
11854             return TRUE;
11855           case 33: /* R_MN10300_SYM_DIFF */
11856             if (sym_index >= num_syms)
11857               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11858                      sym_index);
11859             else
11860               saved_sym = symtab + sym_index;
11861             return TRUE;
11862
11863           case 1: /* R_MN10300_32 */
11864           case 2: /* R_MN10300_16 */
11865             if (saved_sym != NULL)
11866               {
11867                 int reloc_size = reloc_type == 1 ? 4 : 2;
11868                 bfd_vma value;
11869
11870                 if (sym_index >= num_syms)
11871                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11872                          sym_index);
11873                 else
11874                   {
11875                     value = reloc->r_addend + (symtab[sym_index].st_value
11876                                                - saved_sym->st_value);
11877
11878                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11879                       byte_put (start + reloc->r_offset, value, reloc_size);
11880                     else
11881                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11882                              (long) reloc->r_offset);
11883                   }
11884
11885                 saved_sym = NULL;
11886                 return TRUE;
11887               }
11888             break;
11889           default:
11890             if (saved_sym != NULL)
11891               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11892             break;
11893           }
11894         break;
11895       }
11896
11897     case EM_RL78:
11898       {
11899         static bfd_vma saved_sym1 = 0;
11900         static bfd_vma saved_sym2 = 0;
11901         static bfd_vma value;
11902
11903         if (reloc == NULL)
11904           {
11905             saved_sym1 = saved_sym2 = 0;
11906             return TRUE;
11907           }
11908
11909         switch (reloc_type)
11910           {
11911           case 0x80: /* R_RL78_SYM.  */
11912             saved_sym1 = saved_sym2;
11913             if (sym_index >= num_syms)
11914               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11915                      sym_index);
11916             else
11917               {
11918                 saved_sym2 = symtab[sym_index].st_value;
11919                 saved_sym2 += reloc->r_addend;
11920               }
11921             return TRUE;
11922
11923           case 0x83: /* R_RL78_OPsub.  */
11924             value = saved_sym1 - saved_sym2;
11925             saved_sym2 = saved_sym1 = 0;
11926             return TRUE;
11927             break;
11928
11929           case 0x41: /* R_RL78_ABS32.  */
11930             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11931               byte_put (start + reloc->r_offset, value, 4);
11932             else
11933               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11934                      (long) reloc->r_offset);
11935             value = 0;
11936             return TRUE;
11937
11938           case 0x43: /* R_RL78_ABS16.  */
11939             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11940               byte_put (start + reloc->r_offset, value, 2);
11941             else
11942               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11943                      (long) reloc->r_offset);
11944             value = 0;
11945             return TRUE;
11946
11947           default:
11948             break;
11949           }
11950         break;
11951       }
11952     }
11953
11954   return FALSE;
11955 }
11956
11957 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11958    DWARF debug sections.  This is a target specific test.  Note - we do not
11959    go through the whole including-target-headers-multiple-times route, (as
11960    we have already done with <elf/h8.h>) because this would become very
11961    messy and even then this function would have to contain target specific
11962    information (the names of the relocs instead of their numeric values).
11963    FIXME: This is not the correct way to solve this problem.  The proper way
11964    is to have target specific reloc sizing and typing functions created by
11965    the reloc-macros.h header, in the same way that it already creates the
11966    reloc naming functions.  */
11967
11968 static bfd_boolean
11969 is_32bit_abs_reloc (unsigned int reloc_type)
11970 {
11971   /* Please keep this table alpha-sorted for ease of visual lookup.  */
11972   switch (elf_header.e_machine)
11973     {
11974     case EM_386:
11975     case EM_IAMCU:
11976       return reloc_type == 1; /* R_386_32.  */
11977     case EM_68K:
11978       return reloc_type == 1; /* R_68K_32.  */
11979     case EM_860:
11980       return reloc_type == 1; /* R_860_32.  */
11981     case EM_960:
11982       return reloc_type == 2; /* R_960_32.  */
11983     case EM_AARCH64:
11984       return (reloc_type == 258
11985               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11986     case EM_ADAPTEVA_EPIPHANY:
11987       return reloc_type == 3;
11988     case EM_ALPHA:
11989       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
11990     case EM_ARC:
11991       return reloc_type == 1; /* R_ARC_32.  */
11992     case EM_ARC_COMPACT:
11993     case EM_ARC_COMPACT2:
11994       return reloc_type == 4; /* R_ARC_32.  */
11995     case EM_ARM:
11996       return reloc_type == 2; /* R_ARM_ABS32 */
11997     case EM_AVR_OLD:
11998     case EM_AVR:
11999       return reloc_type == 1;
12000     case EM_BLACKFIN:
12001       return reloc_type == 0x12; /* R_byte4_data.  */
12002     case EM_CRIS:
12003       return reloc_type == 3; /* R_CRIS_32.  */
12004     case EM_CR16:
12005       return reloc_type == 3; /* R_CR16_NUM32.  */
12006     case EM_CRX:
12007       return reloc_type == 15; /* R_CRX_NUM32.  */
12008     case EM_CYGNUS_FRV:
12009       return reloc_type == 1;
12010     case EM_CYGNUS_D10V:
12011     case EM_D10V:
12012       return reloc_type == 6; /* R_D10V_32.  */
12013     case EM_CYGNUS_D30V:
12014     case EM_D30V:
12015       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12016     case EM_DLX:
12017       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12018     case EM_CYGNUS_FR30:
12019     case EM_FR30:
12020       return reloc_type == 3; /* R_FR30_32.  */
12021     case EM_FT32:
12022       return reloc_type == 1; /* R_FT32_32.  */
12023     case EM_H8S:
12024     case EM_H8_300:
12025     case EM_H8_300H:
12026       return reloc_type == 1; /* R_H8_DIR32.  */
12027     case EM_IA_64:
12028       return reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12029         || reloc_type == 0x25;  /* R_IA64_DIR32LSB.  */
12030     case EM_IP2K_OLD:
12031     case EM_IP2K:
12032       return reloc_type == 2; /* R_IP2K_32.  */
12033     case EM_IQ2000:
12034       return reloc_type == 2; /* R_IQ2000_32.  */
12035     case EM_LATTICEMICO32:
12036       return reloc_type == 3; /* R_LM32_32.  */
12037     case EM_M32C_OLD:
12038     case EM_M32C:
12039       return reloc_type == 3; /* R_M32C_32.  */
12040     case EM_M32R:
12041       return reloc_type == 34; /* R_M32R_32_RELA.  */
12042     case EM_68HC11:
12043     case EM_68HC12:
12044       return reloc_type == 6; /* R_M68HC11_32.  */
12045     case EM_MCORE:
12046       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12047     case EM_CYGNUS_MEP:
12048       return reloc_type == 4; /* R_MEP_32.  */
12049     case EM_METAG:
12050       return reloc_type == 2; /* R_METAG_ADDR32.  */
12051     case EM_MICROBLAZE:
12052       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12053     case EM_MIPS:
12054       return reloc_type == 2; /* R_MIPS_32.  */
12055     case EM_MMIX:
12056       return reloc_type == 4; /* R_MMIX_32.  */
12057     case EM_CYGNUS_MN10200:
12058     case EM_MN10200:
12059       return reloc_type == 1; /* R_MN10200_32.  */
12060     case EM_CYGNUS_MN10300:
12061     case EM_MN10300:
12062       return reloc_type == 1; /* R_MN10300_32.  */
12063     case EM_MOXIE:
12064       return reloc_type == 1; /* R_MOXIE_32.  */
12065     case EM_MSP430_OLD:
12066     case EM_MSP430:
12067       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12068     case EM_MT:
12069       return reloc_type == 2; /* R_MT_32.  */
12070     case EM_NDS32:
12071       return reloc_type == 20; /* R_NDS32_RELA.  */
12072     case EM_ALTERA_NIOS2:
12073       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12074     case EM_NIOS32:
12075       return reloc_type == 1; /* R_NIOS_32.  */
12076     case EM_OR1K:
12077       return reloc_type == 1; /* R_OR1K_32.  */
12078     case EM_PARISC:
12079       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12080               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12081     case EM_PJ:
12082     case EM_PJ_OLD:
12083       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12084     case EM_PPC64:
12085       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12086     case EM_PPC:
12087       return reloc_type == 1; /* R_PPC_ADDR32.  */
12088     case EM_TI_PRU:
12089       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12090     case EM_RISCV:
12091       return reloc_type == 1; /* R_RISCV_32.  */
12092     case EM_RL78:
12093       return reloc_type == 1; /* R_RL78_DIR32.  */
12094     case EM_RX:
12095       return reloc_type == 1; /* R_RX_DIR32.  */
12096     case EM_S370:
12097       return reloc_type == 1; /* R_I370_ADDR31.  */
12098     case EM_S390_OLD:
12099     case EM_S390:
12100       return reloc_type == 4; /* R_S390_32.  */
12101     case EM_SCORE:
12102       return reloc_type == 8; /* R_SCORE_ABS32.  */
12103     case EM_SH:
12104       return reloc_type == 1; /* R_SH_DIR32.  */
12105     case EM_SPARC32PLUS:
12106     case EM_SPARCV9:
12107     case EM_SPARC:
12108       return reloc_type == 3 /* R_SPARC_32.  */
12109         || reloc_type == 23; /* R_SPARC_UA32.  */
12110     case EM_SPU:
12111       return reloc_type == 6; /* R_SPU_ADDR32 */
12112     case EM_TI_C6000:
12113       return reloc_type == 1; /* R_C6000_ABS32.  */
12114     case EM_TILEGX:
12115       return reloc_type == 2; /* R_TILEGX_32.  */
12116     case EM_TILEPRO:
12117       return reloc_type == 1; /* R_TILEPRO_32.  */
12118     case EM_CYGNUS_V850:
12119     case EM_V850:
12120       return reloc_type == 6; /* R_V850_ABS32.  */
12121     case EM_V800:
12122       return reloc_type == 0x33; /* R_V810_WORD.  */
12123     case EM_VAX:
12124       return reloc_type == 1; /* R_VAX_32.  */
12125     case EM_VISIUM:
12126       return reloc_type == 3;  /* R_VISIUM_32. */
12127     case EM_WEBASSEMBLY:
12128       return reloc_type == 1;  /* R_WASM32_32.  */
12129     case EM_X86_64:
12130     case EM_L1OM:
12131     case EM_K1OM:
12132       return reloc_type == 10; /* R_X86_64_32.  */
12133     case EM_XC16X:
12134     case EM_C166:
12135       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12136     case EM_XGATE:
12137       return reloc_type == 4; /* R_XGATE_32.  */
12138     case EM_XSTORMY16:
12139       return reloc_type == 1; /* R_XSTROMY16_32.  */
12140     case EM_XTENSA_OLD:
12141     case EM_XTENSA:
12142       return reloc_type == 1; /* R_XTENSA_32.  */
12143     default:
12144       {
12145         static unsigned int prev_warn = 0;
12146
12147         /* Avoid repeating the same warning multiple times.  */
12148         if (prev_warn != elf_header.e_machine)
12149           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12150                  elf_header.e_machine);
12151         prev_warn = elf_header.e_machine;
12152         return FALSE;
12153       }
12154     }
12155 }
12156
12157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12158    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12159
12160 static bfd_boolean
12161 is_32bit_pcrel_reloc (unsigned int reloc_type)
12162 {
12163   switch (elf_header.e_machine)
12164   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12165     {
12166     case EM_386:
12167     case EM_IAMCU:
12168       return reloc_type == 2;  /* R_386_PC32.  */
12169     case EM_68K:
12170       return reloc_type == 4;  /* R_68K_PC32.  */
12171     case EM_AARCH64:
12172       return reloc_type == 261; /* R_AARCH64_PREL32 */
12173     case EM_ADAPTEVA_EPIPHANY:
12174       return reloc_type == 6;
12175     case EM_ALPHA:
12176       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12177     case EM_ARC_COMPACT:
12178     case EM_ARC_COMPACT2:
12179       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12180     case EM_ARM:
12181       return reloc_type == 3;  /* R_ARM_REL32 */
12182     case EM_AVR_OLD:
12183     case EM_AVR:
12184       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12185     case EM_MICROBLAZE:
12186       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12187     case EM_OR1K:
12188       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12189     case EM_PARISC:
12190       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12191     case EM_PPC:
12192       return reloc_type == 26; /* R_PPC_REL32.  */
12193     case EM_PPC64:
12194       return reloc_type == 26; /* R_PPC64_REL32.  */
12195     case EM_S390_OLD:
12196     case EM_S390:
12197       return reloc_type == 5;  /* R_390_PC32.  */
12198     case EM_SH:
12199       return reloc_type == 2;  /* R_SH_REL32.  */
12200     case EM_SPARC32PLUS:
12201     case EM_SPARCV9:
12202     case EM_SPARC:
12203       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12204     case EM_SPU:
12205       return reloc_type == 13; /* R_SPU_REL32.  */
12206     case EM_TILEGX:
12207       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12208     case EM_TILEPRO:
12209       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12210     case EM_VISIUM:
12211       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12212     case EM_X86_64:
12213     case EM_L1OM:
12214     case EM_K1OM:
12215       return reloc_type == 2;  /* R_X86_64_PC32.  */
12216     case EM_XTENSA_OLD:
12217     case EM_XTENSA:
12218       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12219     default:
12220       /* Do not abort or issue an error message here.  Not all targets use
12221          pc-relative 32-bit relocs in their DWARF debug information and we
12222          have already tested for target coverage in is_32bit_abs_reloc.  A
12223          more helpful warning message will be generated by apply_relocations
12224          anyway, so just return.  */
12225       return FALSE;
12226     }
12227 }
12228
12229 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12230    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12231
12232 static bfd_boolean
12233 is_64bit_abs_reloc (unsigned int reloc_type)
12234 {
12235   switch (elf_header.e_machine)
12236     {
12237     case EM_AARCH64:
12238       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12239     case EM_ALPHA:
12240       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12241     case EM_IA_64:
12242       return reloc_type == 0x27; /* R_IA64_DIR64LSB.  */
12243     case EM_PARISC:
12244       return reloc_type == 80; /* R_PARISC_DIR64.  */
12245     case EM_PPC64:
12246       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12247     case EM_RISCV:
12248       return reloc_type == 2; /* R_RISCV_64.  */
12249     case EM_SPARC32PLUS:
12250     case EM_SPARCV9:
12251     case EM_SPARC:
12252       return reloc_type == 54; /* R_SPARC_UA64.  */
12253     case EM_X86_64:
12254     case EM_L1OM:
12255     case EM_K1OM:
12256       return reloc_type == 1; /* R_X86_64_64.  */
12257     case EM_S390_OLD:
12258     case EM_S390:
12259       return reloc_type == 22;  /* R_S390_64.  */
12260     case EM_TILEGX:
12261       return reloc_type == 1; /* R_TILEGX_64.  */
12262     case EM_MIPS:
12263       return reloc_type == 18;  /* R_MIPS_64.  */
12264     default:
12265       return FALSE;
12266     }
12267 }
12268
12269 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12270    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12271
12272 static bfd_boolean
12273 is_64bit_pcrel_reloc (unsigned int reloc_type)
12274 {
12275   switch (elf_header.e_machine)
12276     {
12277     case EM_AARCH64:
12278       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12279     case EM_ALPHA:
12280       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12281     case EM_IA_64:
12282       return reloc_type == 0x4f; /* R_IA64_PCREL64LSB.  */
12283     case EM_PARISC:
12284       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12285     case EM_PPC64:
12286       return reloc_type == 44; /* R_PPC64_REL64.  */
12287     case EM_SPARC32PLUS:
12288     case EM_SPARCV9:
12289     case EM_SPARC:
12290       return reloc_type == 46; /* R_SPARC_DISP64.  */
12291     case EM_X86_64:
12292     case EM_L1OM:
12293     case EM_K1OM:
12294       return reloc_type == 24; /* R_X86_64_PC64.  */
12295     case EM_S390_OLD:
12296     case EM_S390:
12297       return reloc_type == 23;  /* R_S390_PC64.  */
12298     case EM_TILEGX:
12299       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12300     default:
12301       return FALSE;
12302     }
12303 }
12304
12305 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12306    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12307
12308 static bfd_boolean
12309 is_24bit_abs_reloc (unsigned int reloc_type)
12310 {
12311   switch (elf_header.e_machine)
12312     {
12313     case EM_CYGNUS_MN10200:
12314     case EM_MN10200:
12315       return reloc_type == 4; /* R_MN10200_24.  */
12316     case EM_FT32:
12317       return reloc_type == 5; /* R_FT32_20.  */
12318     default:
12319       return FALSE;
12320     }
12321 }
12322
12323 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12324    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12325
12326 static bfd_boolean
12327 is_16bit_abs_reloc (unsigned int reloc_type)
12328 {
12329   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12330   switch (elf_header.e_machine)
12331     {
12332     case EM_ARC:
12333     case EM_ARC_COMPACT:
12334     case EM_ARC_COMPACT2:
12335       return reloc_type == 2; /* R_ARC_16.  */
12336     case EM_ADAPTEVA_EPIPHANY:
12337       return reloc_type == 5;
12338     case EM_AVR_OLD:
12339     case EM_AVR:
12340       return reloc_type == 4; /* R_AVR_16.  */
12341     case EM_CYGNUS_D10V:
12342     case EM_D10V:
12343       return reloc_type == 3; /* R_D10V_16.  */
12344     case EM_H8S:
12345     case EM_H8_300:
12346     case EM_H8_300H:
12347       return reloc_type == R_H8_DIR16;
12348     case EM_IP2K_OLD:
12349     case EM_IP2K:
12350       return reloc_type == 1; /* R_IP2K_16.  */
12351     case EM_M32C_OLD:
12352     case EM_M32C:
12353       return reloc_type == 1; /* R_M32C_16 */
12354     case EM_CYGNUS_MN10200:
12355     case EM_MN10200:
12356       return reloc_type == 2; /* R_MN10200_16.  */
12357     case EM_CYGNUS_MN10300:
12358     case EM_MN10300:
12359       return reloc_type == 2; /* R_MN10300_16.  */
12360     case EM_MSP430:
12361       if (uses_msp430x_relocs ())
12362         return reloc_type == 2; /* R_MSP430_ABS16.  */
12363       /* Fall through.  */
12364     case EM_MSP430_OLD:
12365       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12366     case EM_NDS32:
12367       return reloc_type == 19; /* R_NDS32_RELA.  */
12368     case EM_ALTERA_NIOS2:
12369       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12370     case EM_NIOS32:
12371       return reloc_type == 9; /* R_NIOS_16.  */
12372     case EM_OR1K:
12373       return reloc_type == 2; /* R_OR1K_16.  */
12374     case EM_TI_PRU:
12375       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12376     case EM_TI_C6000:
12377       return reloc_type == 2; /* R_C6000_ABS16.  */
12378     case EM_VISIUM:
12379       return reloc_type == 2; /* R_VISIUM_16. */
12380     case EM_XC16X:
12381     case EM_C166:
12382       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12383     case EM_XGATE:
12384       return reloc_type == 3; /* R_XGATE_16.  */
12385     default:
12386       return FALSE;
12387     }
12388 }
12389
12390 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12391    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12392
12393 static bfd_boolean
12394 is_none_reloc (unsigned int reloc_type)
12395 {
12396   switch (elf_header.e_machine)
12397     {
12398     case EM_386:     /* R_386_NONE.  */
12399     case EM_68K:     /* R_68K_NONE.  */
12400     case EM_ADAPTEVA_EPIPHANY:
12401     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12402     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12403     case EM_ARC:     /* R_ARC_NONE.  */
12404     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12405     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12406     case EM_ARM:     /* R_ARM_NONE.  */
12407     case EM_C166:    /* R_XC16X_NONE.  */
12408     case EM_CRIS:    /* R_CRIS_NONE.  */
12409     case EM_FT32:    /* R_FT32_NONE.  */
12410     case EM_IA_64:   /* R_IA64_NONE.  */
12411     case EM_K1OM:    /* R_X86_64_NONE.  */
12412     case EM_L1OM:    /* R_X86_64_NONE.  */
12413     case EM_M32R:    /* R_M32R_NONE.  */
12414     case EM_MIPS:    /* R_MIPS_NONE.  */
12415     case EM_MN10300: /* R_MN10300_NONE.  */
12416     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12417     case EM_NIOS32:  /* R_NIOS_NONE.  */
12418     case EM_OR1K:    /* R_OR1K_NONE. */
12419     case EM_PARISC:  /* R_PARISC_NONE.  */
12420     case EM_PPC64:   /* R_PPC64_NONE.  */
12421     case EM_PPC:     /* R_PPC_NONE.  */
12422     case EM_RISCV:   /* R_RISCV_NONE.  */
12423     case EM_S390:    /* R_390_NONE.  */
12424     case EM_S390_OLD:
12425     case EM_SH:      /* R_SH_NONE.  */
12426     case EM_SPARC32PLUS:
12427     case EM_SPARC:   /* R_SPARC_NONE.  */
12428     case EM_SPARCV9:
12429     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12430     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12431     case EM_TI_C6000:/* R_C6000_NONE.  */
12432     case EM_X86_64:  /* R_X86_64_NONE.  */
12433     case EM_XC16X:
12434     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12435       return reloc_type == 0;
12436
12437     case EM_AARCH64:
12438       return reloc_type == 0 || reloc_type == 256;
12439     case EM_AVR_OLD:
12440     case EM_AVR:
12441       return (reloc_type == 0 /* R_AVR_NONE.  */
12442               || reloc_type == 30 /* R_AVR_DIFF8.  */
12443               || reloc_type == 31 /* R_AVR_DIFF16.  */
12444               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12445     case EM_METAG:
12446       return reloc_type == 3; /* R_METAG_NONE.  */
12447     case EM_NDS32:
12448       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12449               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12450               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12451               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12452               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12453     case EM_TI_PRU:
12454       return (reloc_type == 0       /* R_PRU_NONE.  */
12455               || reloc_type == 65   /* R_PRU_DIFF8.  */
12456               || reloc_type == 66   /* R_PRU_DIFF16.  */
12457               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12458     case EM_XTENSA_OLD:
12459     case EM_XTENSA:
12460       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12461               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12462               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12463               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12464     }
12465   return FALSE;
12466 }
12467
12468 /* Returns TRUE if there is a relocation against
12469    section NAME at OFFSET bytes.  */
12470
12471 bfd_boolean
12472 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12473 {
12474   Elf_Internal_Rela * relocs;
12475   Elf_Internal_Rela * rp;
12476
12477   if (dsec == NULL || dsec->reloc_info == NULL)
12478     return FALSE;
12479
12480   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12481
12482   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12483     if (rp->r_offset == offset)
12484       return TRUE;
12485
12486    return FALSE;
12487 }
12488
12489 /* Apply relocations to a section.
12490    Returns TRUE upon success, FALSE otherwise.
12491    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12492    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12493    will be set to the number of relocs loaded.
12494
12495    Note: So far support has been added only for those relocations
12496    which can be found in debug sections. FIXME: Add support for
12497    more relocations ?  */
12498
12499 static bfd_boolean
12500 apply_relocations (void *                     file,
12501                    const Elf_Internal_Shdr *  section,
12502                    unsigned char *            start,
12503                    bfd_size_type              size,
12504                    void **                    relocs_return,
12505                    unsigned long *            num_relocs_return)
12506 {
12507   Elf_Internal_Shdr * relsec;
12508   unsigned char * end = start + size;
12509   bfd_boolean res = TRUE;
12510
12511   if (relocs_return != NULL)
12512     {
12513       * (Elf_Internal_Rela **) relocs_return = NULL;
12514       * num_relocs_return = 0;
12515     }
12516
12517   if (elf_header.e_type != ET_REL)
12518     /* No relocs to apply.  */
12519     return TRUE;
12520
12521   /* Find the reloc section associated with the section.  */
12522   for (relsec = section_headers;
12523        relsec < section_headers + elf_header.e_shnum;
12524        ++relsec)
12525     {
12526       bfd_boolean is_rela;
12527       unsigned long num_relocs;
12528       Elf_Internal_Rela * relocs;
12529       Elf_Internal_Rela * rp;
12530       Elf_Internal_Shdr * symsec;
12531       Elf_Internal_Sym * symtab;
12532       unsigned long num_syms;
12533       Elf_Internal_Sym * sym;
12534
12535       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12536           || relsec->sh_info >= elf_header.e_shnum
12537           || section_headers + relsec->sh_info != section
12538           || relsec->sh_size == 0
12539           || relsec->sh_link >= elf_header.e_shnum)
12540         continue;
12541
12542       is_rela = relsec->sh_type == SHT_RELA;
12543
12544       if (is_rela)
12545         {
12546           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12547                                   relsec->sh_size, & relocs, & num_relocs))
12548             return FALSE;
12549         }
12550       else
12551         {
12552           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12553                                  relsec->sh_size, & relocs, & num_relocs))
12554             return FALSE;
12555         }
12556
12557       /* SH uses RELA but uses in place value instead of the addend field.  */
12558       if (elf_header.e_machine == EM_SH)
12559         is_rela = FALSE;
12560
12561       symsec = section_headers + relsec->sh_link;
12562       if (symsec->sh_type != SHT_SYMTAB
12563           && symsec->sh_type != SHT_DYNSYM)
12564         return FALSE;
12565       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12566
12567       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12568         {
12569           bfd_vma         addend;
12570           unsigned int    reloc_type;
12571           unsigned int    reloc_size;
12572           unsigned char * rloc;
12573           unsigned long   sym_index;
12574
12575           reloc_type = get_reloc_type (rp->r_info);
12576
12577           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12578             continue;
12579           else if (is_none_reloc (reloc_type))
12580             continue;
12581           else if (is_32bit_abs_reloc (reloc_type)
12582                    || is_32bit_pcrel_reloc (reloc_type))
12583             reloc_size = 4;
12584           else if (is_64bit_abs_reloc (reloc_type)
12585                    || is_64bit_pcrel_reloc (reloc_type))
12586             reloc_size = 8;
12587           else if (is_24bit_abs_reloc (reloc_type))
12588             reloc_size = 3;
12589           else if (is_16bit_abs_reloc (reloc_type))
12590             reloc_size = 2;
12591           else
12592             {
12593               static unsigned int prev_reloc = 0;
12594               if (reloc_type != prev_reloc)
12595                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12596                       reloc_type, printable_section_name (section));
12597               prev_reloc = reloc_type;
12598               res = FALSE;
12599               continue;
12600             }
12601
12602           rloc = start + rp->r_offset;
12603           if ((rloc + reloc_size) > end || (rloc < start))
12604             {
12605               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12606                     (unsigned long) rp->r_offset,
12607                     printable_section_name (section));
12608               res = FALSE;
12609               continue;
12610             }
12611
12612           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12613           if (sym_index >= num_syms)
12614             {
12615               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12616                     sym_index, printable_section_name (section));
12617               res = FALSE;
12618               continue;
12619             }
12620           sym = symtab + sym_index;
12621
12622           /* If the reloc has a symbol associated with it,
12623              make sure that it is of an appropriate type.
12624
12625              Relocations against symbols without type can happen.
12626              Gcc -feliminate-dwarf2-dups may generate symbols
12627              without type for debug info.
12628
12629              Icc generates relocations against function symbols
12630              instead of local labels.
12631
12632              Relocations against object symbols can happen, eg when
12633              referencing a global array.  For an example of this see
12634              the _clz.o binary in libgcc.a.  */
12635           if (sym != symtab
12636               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12637               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12638             {
12639               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12640                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12641                     (long int)(rp - relocs),
12642                     printable_section_name (relsec));
12643               res = FALSE;
12644               continue;
12645             }
12646
12647           addend = 0;
12648           if (is_rela)
12649             addend += rp->r_addend;
12650           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12651              partial_inplace.  */
12652           if (!is_rela
12653               || (elf_header.e_machine == EM_XTENSA
12654                   && reloc_type == 1)
12655               || ((elf_header.e_machine == EM_PJ
12656                    || elf_header.e_machine == EM_PJ_OLD)
12657                   && reloc_type == 1)
12658               || ((elf_header.e_machine == EM_D30V
12659                    || elf_header.e_machine == EM_CYGNUS_D30V)
12660                   && reloc_type == 12))
12661             addend += byte_get (rloc, reloc_size);
12662
12663           if (is_32bit_pcrel_reloc (reloc_type)
12664               || is_64bit_pcrel_reloc (reloc_type))
12665             {
12666               /* On HPPA, all pc-relative relocations are biased by 8.  */
12667               if (elf_header.e_machine == EM_PARISC)
12668                 addend -= 8;
12669               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12670                         reloc_size);
12671             }
12672           else
12673             byte_put (rloc, addend + sym->st_value, reloc_size);
12674         }
12675
12676       free (symtab);
12677       /* Let the target specific reloc processing code know that
12678          we have finished with these relocs.  */
12679       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12680
12681       if (relocs_return)
12682         {
12683           * (Elf_Internal_Rela **) relocs_return = relocs;
12684           * num_relocs_return = num_relocs;
12685         }
12686       else
12687         free (relocs);
12688
12689       break;
12690     }
12691
12692   return res;
12693 }
12694
12695 #ifdef SUPPORT_DISASSEMBLY
12696 static bfd_boolean
12697 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12698 {
12699   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12700
12701   /* FIXME: XXX -- to be done --- XXX */
12702
12703   return TRUE;
12704 }
12705 #endif
12706
12707 /* Reads in the contents of SECTION from FILE, returning a pointer
12708    to a malloc'ed buffer or NULL if something went wrong.  */
12709
12710 static char *
12711 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12712 {
12713   bfd_size_type num_bytes;
12714
12715   num_bytes = section->sh_size;
12716
12717   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12718     {
12719       printf (_("\nSection '%s' has no data to dump.\n"),
12720               printable_section_name (section));
12721       return NULL;
12722     }
12723
12724   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12725                              _("section contents"));
12726 }
12727
12728 /* Uncompresses a section that was compressed using zlib, in place.  */
12729
12730 static bfd_boolean
12731 uncompress_section_contents (unsigned char **buffer,
12732                              dwarf_size_type uncompressed_size,
12733                              dwarf_size_type *size)
12734 {
12735   dwarf_size_type compressed_size = *size;
12736   unsigned char * compressed_buffer = *buffer;
12737   unsigned char * uncompressed_buffer;
12738   z_stream strm;
12739   int rc;
12740
12741   /* It is possible the section consists of several compressed
12742      buffers concatenated together, so we uncompress in a loop.  */
12743   /* PR 18313: The state field in the z_stream structure is supposed
12744      to be invisible to the user (ie us), but some compilers will
12745      still complain about it being used without initialisation.  So
12746      we first zero the entire z_stream structure and then set the fields
12747      that we need.  */
12748   memset (& strm, 0, sizeof strm);
12749   strm.avail_in = compressed_size;
12750   strm.next_in = (Bytef *) compressed_buffer;
12751   strm.avail_out = uncompressed_size;
12752   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12753
12754   rc = inflateInit (& strm);
12755   while (strm.avail_in > 0)
12756     {
12757       if (rc != Z_OK)
12758         goto fail;
12759       strm.next_out = ((Bytef *) uncompressed_buffer
12760                        + (uncompressed_size - strm.avail_out));
12761       rc = inflate (&strm, Z_FINISH);
12762       if (rc != Z_STREAM_END)
12763         goto fail;
12764       rc = inflateReset (& strm);
12765     }
12766   rc = inflateEnd (& strm);
12767   if (rc != Z_OK
12768       || strm.avail_out != 0)
12769     goto fail;
12770
12771   *buffer = uncompressed_buffer;
12772   *size = uncompressed_size;
12773   return TRUE;
12774
12775  fail:
12776   free (uncompressed_buffer);
12777   /* Indicate decompression failure.  */
12778   *buffer = NULL;
12779   return FALSE;
12780 }
12781
12782 static bfd_boolean
12783 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12784 {
12785   Elf_Internal_Shdr *  relsec;
12786   bfd_size_type        num_bytes;
12787   unsigned char *      data;
12788   unsigned char *      end;
12789   unsigned char *      real_start;
12790   unsigned char *      start;
12791   bfd_boolean          some_strings_shown;
12792
12793   real_start = start = (unsigned char *) get_section_contents (section,
12794                                                                file);
12795   if (start == NULL)
12796     return FALSE;
12797   num_bytes = section->sh_size;
12798
12799   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12800
12801   if (decompress_dumps)
12802     {
12803       dwarf_size_type new_size = num_bytes;
12804       dwarf_size_type uncompressed_size = 0;
12805
12806       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12807         {
12808           Elf_Internal_Chdr chdr;
12809           unsigned int compression_header_size
12810             = get_compression_header (& chdr, (unsigned char *) start,
12811                                       num_bytes);
12812
12813           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12814             {
12815               warn (_("section '%s' has unsupported compress type: %d\n"),
12816                     printable_section_name (section), chdr.ch_type);
12817               return FALSE;
12818             }
12819           else if (chdr.ch_addralign != section->sh_addralign)
12820             {
12821               warn (_("compressed section '%s' is corrupted\n"),
12822                     printable_section_name (section));
12823               return FALSE;
12824             }
12825           uncompressed_size = chdr.ch_size;
12826           start += compression_header_size;
12827           new_size -= compression_header_size;
12828         }
12829       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12830         {
12831           /* Read the zlib header.  In this case, it should be "ZLIB"
12832              followed by the uncompressed section size, 8 bytes in
12833              big-endian order.  */
12834           uncompressed_size = start[4]; uncompressed_size <<= 8;
12835           uncompressed_size += start[5]; uncompressed_size <<= 8;
12836           uncompressed_size += start[6]; uncompressed_size <<= 8;
12837           uncompressed_size += start[7]; uncompressed_size <<= 8;
12838           uncompressed_size += start[8]; uncompressed_size <<= 8;
12839           uncompressed_size += start[9]; uncompressed_size <<= 8;
12840           uncompressed_size += start[10]; uncompressed_size <<= 8;
12841           uncompressed_size += start[11];
12842           start += 12;
12843           new_size -= 12;
12844         }
12845
12846       if (uncompressed_size)
12847         {
12848           if (uncompress_section_contents (& start,
12849                                            uncompressed_size, & new_size))
12850             num_bytes = new_size;
12851           else
12852             {
12853               error (_("Unable to decompress section %s\n"),
12854                      printable_section_name (section));
12855               return FALSE;
12856             }
12857         }
12858       else
12859         start = real_start;
12860     }
12861
12862   /* If the section being dumped has relocations against it the user might
12863      be expecting these relocations to have been applied.  Check for this
12864      case and issue a warning message in order to avoid confusion.
12865      FIXME: Maybe we ought to have an option that dumps a section with
12866      relocs applied ?  */
12867   for (relsec = section_headers;
12868        relsec < section_headers + elf_header.e_shnum;
12869        ++relsec)
12870     {
12871       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12872           || relsec->sh_info >= elf_header.e_shnum
12873           || section_headers + relsec->sh_info != section
12874           || relsec->sh_size == 0
12875           || relsec->sh_link >= elf_header.e_shnum)
12876         continue;
12877
12878       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12879       break;
12880     }
12881
12882   data = start;
12883   end  = start + num_bytes;
12884   some_strings_shown = FALSE;
12885
12886   while (data < end)
12887     {
12888       while (!ISPRINT (* data))
12889         if (++ data >= end)
12890           break;
12891
12892       if (data < end)
12893         {
12894           size_t maxlen = end - data;
12895
12896 #ifndef __MSVCRT__
12897           /* PR 11128: Use two separate invocations in order to work
12898              around bugs in the Solaris 8 implementation of printf.  */
12899           printf ("  [%6tx]  ", data - start);
12900 #else
12901           printf ("  [%6Ix]  ", (size_t) (data - start));
12902 #endif
12903           if (maxlen > 0)
12904             {
12905               print_symbol ((int) maxlen, (const char *) data);
12906               putchar ('\n');
12907               data += strnlen ((const char *) data, maxlen);
12908             }
12909           else
12910             {
12911               printf (_("<corrupt>\n"));
12912               data = end;
12913             }
12914           some_strings_shown = TRUE;
12915         }
12916     }
12917
12918   if (! some_strings_shown)
12919     printf (_("  No strings found in this section."));
12920
12921   free (real_start);
12922
12923   putchar ('\n');
12924   return TRUE;
12925 }
12926
12927 static bfd_boolean
12928 dump_section_as_bytes (Elf_Internal_Shdr * section,
12929                        FILE * file,
12930                        bfd_boolean relocate)
12931 {
12932   Elf_Internal_Shdr * relsec;
12933   bfd_size_type       bytes;
12934   bfd_size_type       section_size;
12935   bfd_vma             addr;
12936   unsigned char *     data;
12937   unsigned char *     real_start;
12938   unsigned char *     start;
12939
12940   real_start = start = (unsigned char *) get_section_contents (section, file);
12941   if (start == NULL)
12942     return FALSE;
12943
12944   section_size = section->sh_size;
12945
12946   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12947
12948   if (decompress_dumps)
12949     {
12950       dwarf_size_type new_size = section_size;
12951       dwarf_size_type uncompressed_size = 0;
12952
12953       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12954         {
12955           Elf_Internal_Chdr chdr;
12956           unsigned int compression_header_size
12957             = get_compression_header (& chdr, start, section_size);
12958
12959           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12960             {
12961               warn (_("section '%s' has unsupported compress type: %d\n"),
12962                     printable_section_name (section), chdr.ch_type);
12963               return FALSE;
12964             }
12965           else if (chdr.ch_addralign != section->sh_addralign)
12966             {
12967               warn (_("compressed section '%s' is corrupted\n"),
12968                     printable_section_name (section));
12969               return FALSE;
12970             }
12971           uncompressed_size = chdr.ch_size;
12972           start += compression_header_size;
12973           new_size -= compression_header_size;
12974         }
12975       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12976         {
12977           /* Read the zlib header.  In this case, it should be "ZLIB"
12978              followed by the uncompressed section size, 8 bytes in
12979              big-endian order.  */
12980           uncompressed_size = start[4]; uncompressed_size <<= 8;
12981           uncompressed_size += start[5]; uncompressed_size <<= 8;
12982           uncompressed_size += start[6]; uncompressed_size <<= 8;
12983           uncompressed_size += start[7]; uncompressed_size <<= 8;
12984           uncompressed_size += start[8]; uncompressed_size <<= 8;
12985           uncompressed_size += start[9]; uncompressed_size <<= 8;
12986           uncompressed_size += start[10]; uncompressed_size <<= 8;
12987           uncompressed_size += start[11];
12988           start += 12;
12989           new_size -= 12;
12990         }
12991
12992       if (uncompressed_size)
12993         {
12994           if (uncompress_section_contents (& start, uncompressed_size,
12995                                            & new_size))
12996             {
12997               section_size = new_size;
12998             }
12999           else
13000             {
13001               error (_("Unable to decompress section %s\n"),
13002                      printable_section_name (section));
13003               /* FIXME: Print the section anyway ?  */
13004               return FALSE;
13005             }
13006         }
13007       else
13008         start = real_start;
13009     }
13010
13011   if (relocate)
13012     {
13013       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13014         return FALSE;
13015     }
13016   else
13017     {
13018       /* If the section being dumped has relocations against it the user might
13019          be expecting these relocations to have been applied.  Check for this
13020          case and issue a warning message in order to avoid confusion.
13021          FIXME: Maybe we ought to have an option that dumps a section with
13022          relocs applied ?  */
13023       for (relsec = section_headers;
13024            relsec < section_headers + elf_header.e_shnum;
13025            ++relsec)
13026         {
13027           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13028               || relsec->sh_info >= elf_header.e_shnum
13029               || section_headers + relsec->sh_info != section
13030               || relsec->sh_size == 0
13031               || relsec->sh_link >= elf_header.e_shnum)
13032             continue;
13033
13034           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13035           break;
13036         }
13037     }
13038
13039   addr = section->sh_addr;
13040   bytes = section_size;
13041   data = start;
13042
13043   while (bytes)
13044     {
13045       int j;
13046       int k;
13047       int lbytes;
13048
13049       lbytes = (bytes > 16 ? 16 : bytes);
13050
13051       printf ("  0x%8.8lx ", (unsigned long) addr);
13052
13053       for (j = 0; j < 16; j++)
13054         {
13055           if (j < lbytes)
13056             printf ("%2.2x", data[j]);
13057           else
13058             printf ("  ");
13059
13060           if ((j & 3) == 3)
13061             printf (" ");
13062         }
13063
13064       for (j = 0; j < lbytes; j++)
13065         {
13066           k = data[j];
13067           if (k >= ' ' && k < 0x7f)
13068             printf ("%c", k);
13069           else
13070             printf (".");
13071         }
13072
13073       putchar ('\n');
13074
13075       data  += lbytes;
13076       addr  += lbytes;
13077       bytes -= lbytes;
13078     }
13079
13080   free (real_start);
13081
13082   putchar ('\n');
13083   return TRUE;
13084 }
13085
13086 static bfd_boolean
13087 load_specific_debug_section (enum dwarf_section_display_enum debug,
13088                              const Elf_Internal_Shdr * sec, void * file)
13089 {
13090   struct dwarf_section * section = &debug_displays [debug].section;
13091   char buf [64];
13092
13093   /* If it is already loaded, do nothing.  */
13094   if (section->start != NULL)
13095     return TRUE;
13096
13097   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13098   section->address = sec->sh_addr;
13099   section->user_data = NULL;
13100   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13101                                                sec->sh_offset, 1,
13102                                                sec->sh_size, buf);
13103   if (section->start == NULL)
13104     section->size = 0;
13105   else
13106     {
13107       unsigned char *start = section->start;
13108       dwarf_size_type size = sec->sh_size;
13109       dwarf_size_type uncompressed_size = 0;
13110
13111       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13112         {
13113           Elf_Internal_Chdr chdr;
13114           unsigned int compression_header_size;
13115
13116           if (size < (is_32bit_elf
13117                       ? sizeof (Elf32_External_Chdr)
13118                       : sizeof (Elf64_External_Chdr)))
13119             {
13120               warn (_("compressed section %s is too small to contain a compression header"),
13121                     section->name);
13122               return FALSE;
13123             }
13124
13125           compression_header_size = get_compression_header (&chdr, start, size);
13126
13127           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13128             {
13129               warn (_("section '%s' has unsupported compress type: %d\n"),
13130                     section->name, chdr.ch_type);
13131               return FALSE;
13132             }
13133           else if (chdr.ch_addralign != sec->sh_addralign)
13134             {
13135               warn (_("compressed section '%s' is corrupted\n"),
13136                     section->name);
13137               return FALSE;
13138             }
13139           uncompressed_size = chdr.ch_size;
13140           start += compression_header_size;
13141           size -= compression_header_size;
13142         }
13143       else if (size > 12 && streq ((char *) start, "ZLIB"))
13144         {
13145           /* Read the zlib header.  In this case, it should be "ZLIB"
13146              followed by the uncompressed section size, 8 bytes in
13147              big-endian order.  */
13148           uncompressed_size = start[4]; uncompressed_size <<= 8;
13149           uncompressed_size += start[5]; uncompressed_size <<= 8;
13150           uncompressed_size += start[6]; uncompressed_size <<= 8;
13151           uncompressed_size += start[7]; uncompressed_size <<= 8;
13152           uncompressed_size += start[8]; uncompressed_size <<= 8;
13153           uncompressed_size += start[9]; uncompressed_size <<= 8;
13154           uncompressed_size += start[10]; uncompressed_size <<= 8;
13155           uncompressed_size += start[11];
13156           start += 12;
13157           size -= 12;
13158         }
13159
13160       if (uncompressed_size)
13161         {
13162           if (uncompress_section_contents (&start, uncompressed_size,
13163                                            &size))
13164             {
13165               /* Free the compressed buffer, update the section buffer
13166                  and the section size if uncompress is successful.  */
13167               free (section->start);
13168               section->start = start;
13169             }
13170           else
13171             {
13172               error (_("Unable to decompress section %s\n"),
13173                      printable_section_name (sec));
13174               return FALSE;
13175             }
13176         }
13177
13178       section->size = size;
13179     }
13180
13181   if (section->start == NULL)
13182     return FALSE;
13183
13184   if (debug_displays [debug].relocate)
13185     {
13186       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13187                                & section->reloc_info, & section->num_relocs))
13188         return FALSE;
13189     }
13190   else
13191     {
13192       section->reloc_info = NULL;
13193       section->num_relocs = 0;
13194     }
13195
13196   return TRUE;
13197 }
13198
13199 /* If this is not NULL, load_debug_section will only look for sections
13200    within the list of sections given here.  */
13201 static unsigned int * section_subset = NULL;
13202
13203 bfd_boolean
13204 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13205 {
13206   struct dwarf_section * section = &debug_displays [debug].section;
13207   Elf_Internal_Shdr * sec;
13208
13209   /* Locate the debug section.  */
13210   sec = find_section_in_set (section->uncompressed_name, section_subset);
13211   if (sec != NULL)
13212     section->name = section->uncompressed_name;
13213   else
13214     {
13215       sec = find_section_in_set (section->compressed_name, section_subset);
13216       if (sec != NULL)
13217         section->name = section->compressed_name;
13218     }
13219   if (sec == NULL)
13220     return FALSE;
13221
13222   /* If we're loading from a subset of sections, and we've loaded
13223      a section matching this name before, it's likely that it's a
13224      different one.  */
13225   if (section_subset != NULL)
13226     free_debug_section (debug);
13227
13228   return load_specific_debug_section (debug, sec, (FILE *) file);
13229 }
13230
13231 void
13232 free_debug_section (enum dwarf_section_display_enum debug)
13233 {
13234   struct dwarf_section * section = &debug_displays [debug].section;
13235
13236   if (section->start == NULL)
13237     return;
13238
13239   free ((char *) section->start);
13240   section->start = NULL;
13241   section->address = 0;
13242   section->size = 0;
13243 }
13244
13245 static bfd_boolean
13246 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13247 {
13248   char * name = SECTION_NAME (section);
13249   const char * print_name = printable_section_name (section);
13250   bfd_size_type length;
13251   bfd_boolean result = TRUE;
13252   int i;
13253
13254   length = section->sh_size;
13255   if (length == 0)
13256     {
13257       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13258       return TRUE;
13259     }
13260   if (section->sh_type == SHT_NOBITS)
13261     {
13262       /* There is no point in dumping the contents of a debugging section
13263          which has the NOBITS type - the bits in the file will be random.
13264          This can happen when a file containing a .eh_frame section is
13265          stripped with the --only-keep-debug command line option.  */
13266       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13267               print_name);
13268       return FALSE;
13269     }
13270
13271   if (const_strneq (name, ".gnu.linkonce.wi."))
13272     name = ".debug_info";
13273
13274   /* See if we know how to display the contents of this section.  */
13275   for (i = 0; i < max; i++)
13276     if (streq (debug_displays[i].section.uncompressed_name, name)
13277         || (i == line && const_strneq (name, ".debug_line."))
13278         || streq (debug_displays[i].section.compressed_name, name))
13279       {
13280         struct dwarf_section * sec = &debug_displays [i].section;
13281         int secondary = (section != find_section (name));
13282
13283         if (secondary)
13284           free_debug_section ((enum dwarf_section_display_enum) i);
13285
13286         if (i == line && const_strneq (name, ".debug_line."))
13287           sec->name = name;
13288         else if (streq (sec->uncompressed_name, name))
13289           sec->name = sec->uncompressed_name;
13290         else
13291           sec->name = sec->compressed_name;
13292         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13293                                          section, file))
13294           {
13295             /* If this debug section is part of a CU/TU set in a .dwp file,
13296                restrict load_debug_section to the sections in that set.  */
13297             section_subset = find_cu_tu_set (file, shndx);
13298
13299             result &= debug_displays[i].display (sec, file);
13300
13301             section_subset = NULL;
13302
13303             if (secondary || (i != info && i != abbrev))
13304               free_debug_section ((enum dwarf_section_display_enum) i);
13305           }
13306
13307         break;
13308       }
13309
13310   if (i == max)
13311     {
13312       printf (_("Unrecognized debug section: %s\n"), print_name);
13313       result = FALSE;
13314     }
13315
13316   return result;
13317 }
13318
13319 /* Set DUMP_SECTS for all sections where dumps were requested
13320    based on section name.  */
13321
13322 static void
13323 initialise_dumps_byname (void)
13324 {
13325   struct dump_list_entry * cur;
13326
13327   for (cur = dump_sects_byname; cur; cur = cur->next)
13328     {
13329       unsigned int i;
13330       bfd_boolean any = FALSE;
13331
13332       for (i = 0; i < elf_header.e_shnum; i++)
13333         if (streq (SECTION_NAME (section_headers + i), cur->name))
13334           {
13335             request_dump_bynumber (i, cur->type);
13336             any = TRUE;
13337           }
13338
13339       if (!any)
13340         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13341               cur->name);
13342     }
13343 }
13344
13345 static bfd_boolean
13346 process_section_contents (FILE * file)
13347 {
13348   Elf_Internal_Shdr * section;
13349   unsigned int i;
13350   bfd_boolean res = TRUE;
13351
13352   if (! do_dump)
13353     return TRUE;
13354
13355   initialise_dumps_byname ();
13356
13357   for (i = 0, section = section_headers;
13358        i < elf_header.e_shnum && i < num_dump_sects;
13359        i++, section++)
13360     {
13361 #ifdef SUPPORT_DISASSEMBLY
13362       if (dump_sects[i] & DISASS_DUMP)
13363         disassemble_section (section, file);
13364 #endif
13365       if (dump_sects[i] & HEX_DUMP)
13366         {
13367           if (! dump_section_as_bytes (section, file, FALSE))
13368             res = FALSE;
13369         }
13370
13371       if (dump_sects[i] & RELOC_DUMP)
13372         {
13373           if (! dump_section_as_bytes (section, file, TRUE))
13374             res = FALSE;
13375         }
13376
13377       if (dump_sects[i] & STRING_DUMP)
13378         {
13379           if (! dump_section_as_strings (section, file))
13380             res = FALSE;
13381         }
13382
13383       if (dump_sects[i] & DEBUG_DUMP)
13384         {
13385           if (! display_debug_section (i, section, file))
13386             res = FALSE;
13387         }
13388     }
13389
13390   /* Check to see if the user requested a
13391      dump of a section that does not exist.  */
13392   while (i < num_dump_sects)
13393     {
13394       if (dump_sects[i])
13395         {
13396           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13397           res = FALSE;
13398         }
13399       i++;
13400     }
13401
13402   return res;
13403 }
13404
13405 static void
13406 process_mips_fpe_exception (int mask)
13407 {
13408   if (mask)
13409     {
13410       bfd_boolean first = TRUE;
13411
13412       if (mask & OEX_FPU_INEX)
13413         fputs ("INEX", stdout), first = FALSE;
13414       if (mask & OEX_FPU_UFLO)
13415         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13416       if (mask & OEX_FPU_OFLO)
13417         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13418       if (mask & OEX_FPU_DIV0)
13419         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13420       if (mask & OEX_FPU_INVAL)
13421         printf ("%sINVAL", first ? "" : "|");
13422     }
13423   else
13424     fputs ("0", stdout);
13425 }
13426
13427 /* Display's the value of TAG at location P.  If TAG is
13428    greater than 0 it is assumed to be an unknown tag, and
13429    a message is printed to this effect.  Otherwise it is
13430    assumed that a message has already been printed.
13431
13432    If the bottom bit of TAG is set it assumed to have a
13433    string value, otherwise it is assumed to have an integer
13434    value.
13435
13436    Returns an updated P pointing to the first unread byte
13437    beyond the end of TAG's value.
13438
13439    Reads at or beyond END will not be made.  */
13440
13441 static unsigned char *
13442 display_tag_value (signed int tag,
13443                    unsigned char * p,
13444                    const unsigned char * const end)
13445 {
13446   unsigned long val;
13447
13448   if (tag > 0)
13449     printf ("  Tag_unknown_%d: ", tag);
13450
13451   if (p >= end)
13452     {
13453       warn (_("<corrupt tag>\n"));
13454     }
13455   else if (tag & 1)
13456     {
13457       /* PR 17531 file: 027-19978-0.004.  */
13458       size_t maxlen = (end - p) - 1;
13459
13460       putchar ('"');
13461       if (maxlen > 0)
13462         {
13463           print_symbol ((int) maxlen, (const char *) p);
13464           p += strnlen ((char *) p, maxlen) + 1;
13465         }
13466       else
13467         {
13468           printf (_("<corrupt string tag>"));
13469           p = (unsigned char *) end;
13470         }
13471       printf ("\"\n");
13472     }
13473   else
13474     {
13475       unsigned int len;
13476
13477       val = read_uleb128 (p, &len, end);
13478       p += len;
13479       printf ("%ld (0x%lx)\n", val, val);
13480     }
13481
13482   assert (p <= end);
13483   return p;
13484 }
13485
13486 /* ARM EABI attributes section.  */
13487 typedef struct
13488 {
13489   unsigned int tag;
13490   const char * name;
13491   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13492   unsigned int type;
13493   const char ** table;
13494 } arm_attr_public_tag;
13495
13496 static const char * arm_attr_tag_CPU_arch[] =
13497   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13498    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13499    "v8-M.mainline"};
13500 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13501 static const char * arm_attr_tag_THUMB_ISA_use[] =
13502   {"No", "Thumb-1", "Thumb-2", "Yes"};
13503 static const char * arm_attr_tag_FP_arch[] =
13504   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13505    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13506 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13507 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13508   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13509    "NEON for ARMv8.1"};
13510 static const char * arm_attr_tag_PCS_config[] =
13511   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13512    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13513 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13514   {"V6", "SB", "TLS", "Unused"};
13515 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13516   {"Absolute", "PC-relative", "SB-relative", "None"};
13517 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13518   {"Absolute", "PC-relative", "None"};
13519 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13520   {"None", "direct", "GOT-indirect"};
13521 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13522   {"None", "??? 1", "2", "??? 3", "4"};
13523 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13524 static const char * arm_attr_tag_ABI_FP_denormal[] =
13525   {"Unused", "Needed", "Sign only"};
13526 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13527 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13528 static const char * arm_attr_tag_ABI_FP_number_model[] =
13529   {"Unused", "Finite", "RTABI", "IEEE 754"};
13530 static const char * arm_attr_tag_ABI_enum_size[] =
13531   {"Unused", "small", "int", "forced to int"};
13532 static const char * arm_attr_tag_ABI_HardFP_use[] =
13533   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13534 static const char * arm_attr_tag_ABI_VFP_args[] =
13535   {"AAPCS", "VFP registers", "custom", "compatible"};
13536 static const char * arm_attr_tag_ABI_WMMX_args[] =
13537   {"AAPCS", "WMMX registers", "custom"};
13538 static const char * arm_attr_tag_ABI_optimization_goals[] =
13539   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13540     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13541 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13542   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13543     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13544 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13545 static const char * arm_attr_tag_FP_HP_extension[] =
13546   {"Not Allowed", "Allowed"};
13547 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13548   {"None", "IEEE 754", "Alternative Format"};
13549 static const char * arm_attr_tag_DSP_extension[] =
13550   {"Follow architecture", "Allowed"};
13551 static const char * arm_attr_tag_MPextension_use[] =
13552   {"Not Allowed", "Allowed"};
13553 static const char * arm_attr_tag_DIV_use[] =
13554   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13555     "Allowed in v7-A with integer division extension"};
13556 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13557 static const char * arm_attr_tag_Virtualization_use[] =
13558   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13559     "TrustZone and Virtualization Extensions"};
13560 static const char * arm_attr_tag_MPextension_use_legacy[] =
13561   {"Not Allowed", "Allowed"};
13562
13563 #define LOOKUP(id, name) \
13564   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13565 static arm_attr_public_tag arm_attr_public_tags[] =
13566 {
13567   {4, "CPU_raw_name", 1, NULL},
13568   {5, "CPU_name", 1, NULL},
13569   LOOKUP(6, CPU_arch),
13570   {7, "CPU_arch_profile", 0, NULL},
13571   LOOKUP(8, ARM_ISA_use),
13572   LOOKUP(9, THUMB_ISA_use),
13573   LOOKUP(10, FP_arch),
13574   LOOKUP(11, WMMX_arch),
13575   LOOKUP(12, Advanced_SIMD_arch),
13576   LOOKUP(13, PCS_config),
13577   LOOKUP(14, ABI_PCS_R9_use),
13578   LOOKUP(15, ABI_PCS_RW_data),
13579   LOOKUP(16, ABI_PCS_RO_data),
13580   LOOKUP(17, ABI_PCS_GOT_use),
13581   LOOKUP(18, ABI_PCS_wchar_t),
13582   LOOKUP(19, ABI_FP_rounding),
13583   LOOKUP(20, ABI_FP_denormal),
13584   LOOKUP(21, ABI_FP_exceptions),
13585   LOOKUP(22, ABI_FP_user_exceptions),
13586   LOOKUP(23, ABI_FP_number_model),
13587   {24, "ABI_align_needed", 0, NULL},
13588   {25, "ABI_align_preserved", 0, NULL},
13589   LOOKUP(26, ABI_enum_size),
13590   LOOKUP(27, ABI_HardFP_use),
13591   LOOKUP(28, ABI_VFP_args),
13592   LOOKUP(29, ABI_WMMX_args),
13593   LOOKUP(30, ABI_optimization_goals),
13594   LOOKUP(31, ABI_FP_optimization_goals),
13595   {32, "compatibility", 0, NULL},
13596   LOOKUP(34, CPU_unaligned_access),
13597   LOOKUP(36, FP_HP_extension),
13598   LOOKUP(38, ABI_FP_16bit_format),
13599   LOOKUP(42, MPextension_use),
13600   LOOKUP(44, DIV_use),
13601   LOOKUP(46, DSP_extension),
13602   {64, "nodefaults", 0, NULL},
13603   {65, "also_compatible_with", 0, NULL},
13604   LOOKUP(66, T2EE_use),
13605   {67, "conformance", 1, NULL},
13606   LOOKUP(68, Virtualization_use),
13607   LOOKUP(70, MPextension_use_legacy)
13608 };
13609 #undef LOOKUP
13610
13611 static unsigned char *
13612 display_arm_attribute (unsigned char * p,
13613                        const unsigned char * const end)
13614 {
13615   unsigned int tag;
13616   unsigned int len;
13617   unsigned int val;
13618   arm_attr_public_tag * attr;
13619   unsigned i;
13620   unsigned int type;
13621
13622   tag = read_uleb128 (p, &len, end);
13623   p += len;
13624   attr = NULL;
13625   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13626     {
13627       if (arm_attr_public_tags[i].tag == tag)
13628         {
13629           attr = &arm_attr_public_tags[i];
13630           break;
13631         }
13632     }
13633
13634   if (attr)
13635     {
13636       printf ("  Tag_%s: ", attr->name);
13637       switch (attr->type)
13638         {
13639         case 0:
13640           switch (tag)
13641             {
13642             case 7: /* Tag_CPU_arch_profile.  */
13643               val = read_uleb128 (p, &len, end);
13644               p += len;
13645               switch (val)
13646                 {
13647                 case 0: printf (_("None\n")); break;
13648                 case 'A': printf (_("Application\n")); break;
13649                 case 'R': printf (_("Realtime\n")); break;
13650                 case 'M': printf (_("Microcontroller\n")); break;
13651                 case 'S': printf (_("Application or Realtime\n")); break;
13652                 default: printf ("??? (%d)\n", val); break;
13653                 }
13654               break;
13655
13656             case 24: /* Tag_align_needed.  */
13657               val = read_uleb128 (p, &len, end);
13658               p += len;
13659               switch (val)
13660                 {
13661                 case 0: printf (_("None\n")); break;
13662                 case 1: printf (_("8-byte\n")); break;
13663                 case 2: printf (_("4-byte\n")); break;
13664                 case 3: printf ("??? 3\n"); break;
13665                 default:
13666                   if (val <= 12)
13667                     printf (_("8-byte and up to %d-byte extended\n"),
13668                             1 << val);
13669                   else
13670                     printf ("??? (%d)\n", val);
13671                   break;
13672                 }
13673               break;
13674
13675             case 25: /* Tag_align_preserved.  */
13676               val = read_uleb128 (p, &len, end);
13677               p += len;
13678               switch (val)
13679                 {
13680                 case 0: printf (_("None\n")); break;
13681                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13682                 case 2: printf (_("8-byte\n")); break;
13683                 case 3: printf ("??? 3\n"); break;
13684                 default:
13685                   if (val <= 12)
13686                     printf (_("8-byte and up to %d-byte extended\n"),
13687                             1 << val);
13688                   else
13689                     printf ("??? (%d)\n", val);
13690                   break;
13691                 }
13692               break;
13693
13694             case 32: /* Tag_compatibility.  */
13695               {
13696                 val = read_uleb128 (p, &len, end);
13697                 p += len;
13698                 printf (_("flag = %d, vendor = "), val);
13699                 if (p < end - 1)
13700                   {
13701                     size_t maxlen = (end - p) - 1;
13702
13703                     print_symbol ((int) maxlen, (const char *) p);
13704                     p += strnlen ((char *) p, maxlen) + 1;
13705                   }
13706                 else
13707                   {
13708                     printf (_("<corrupt>"));
13709                     p = (unsigned char *) end;
13710                   }
13711                 putchar ('\n');
13712               }
13713               break;
13714
13715             case 64: /* Tag_nodefaults.  */
13716               /* PR 17531: file: 001-505008-0.01.  */
13717               if (p < end)
13718                 p++;
13719               printf (_("True\n"));
13720               break;
13721
13722             case 65: /* Tag_also_compatible_with.  */
13723               val = read_uleb128 (p, &len, end);
13724               p += len;
13725               if (val == 6 /* Tag_CPU_arch.  */)
13726                 {
13727                   val = read_uleb128 (p, &len, end);
13728                   p += len;
13729                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13730                     printf ("??? (%d)\n", val);
13731                   else
13732                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13733                 }
13734               else
13735                 printf ("???\n");
13736               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13737                 ;
13738               break;
13739
13740             default:
13741               printf (_("<unknown: %d>\n"), tag);
13742               break;
13743             }
13744           return p;
13745
13746         case 1:
13747           return display_tag_value (-1, p, end);
13748         case 2:
13749           return display_tag_value (0, p, end);
13750
13751         default:
13752           assert (attr->type & 0x80);
13753           val = read_uleb128 (p, &len, end);
13754           p += len;
13755           type = attr->type & 0x7f;
13756           if (val >= type)
13757             printf ("??? (%d)\n", val);
13758           else
13759             printf ("%s\n", attr->table[val]);
13760           return p;
13761         }
13762     }
13763
13764   return display_tag_value (tag, p, end);
13765 }
13766
13767 static unsigned char *
13768 display_gnu_attribute (unsigned char * p,
13769                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13770                        const unsigned char * const end)
13771 {
13772   int tag;
13773   unsigned int len;
13774   unsigned int val;
13775
13776   tag = read_uleb128 (p, &len, end);
13777   p += len;
13778
13779   /* Tag_compatibility is the only generic GNU attribute defined at
13780      present.  */
13781   if (tag == 32)
13782     {
13783       val = read_uleb128 (p, &len, end);
13784       p += len;
13785
13786       printf (_("flag = %d, vendor = "), val);
13787       if (p == end)
13788         {
13789           printf (_("<corrupt>\n"));
13790           warn (_("corrupt vendor attribute\n"));
13791         }
13792       else
13793         {
13794           if (p < end - 1)
13795             {
13796               size_t maxlen = (end - p) - 1;
13797
13798               print_symbol ((int) maxlen, (const char *) p);
13799               p += strnlen ((char *) p, maxlen) + 1;
13800             }
13801           else
13802             {
13803               printf (_("<corrupt>"));
13804               p = (unsigned char *) end;
13805             }
13806           putchar ('\n');
13807         }
13808       return p;
13809     }
13810
13811   if ((tag & 2) == 0 && display_proc_gnu_attribute)
13812     return display_proc_gnu_attribute (p, tag, end);
13813
13814   return display_tag_value (tag, p, end);
13815 }
13816
13817 static unsigned char *
13818 display_power_gnu_attribute (unsigned char * p,
13819                              unsigned int tag,
13820                              const unsigned char * const end)
13821 {
13822   unsigned int len;
13823   unsigned int val;
13824
13825   if (tag == Tag_GNU_Power_ABI_FP)
13826     {
13827       val = read_uleb128 (p, &len, end);
13828       p += len;
13829       printf ("  Tag_GNU_Power_ABI_FP: ");
13830       if (len == 0)
13831         {
13832           printf (_("<corrupt>\n"));
13833           return p;
13834         }
13835
13836       if (val > 15)
13837         printf ("(%#x), ", val);
13838
13839       switch (val & 3)
13840         {
13841         case 0:
13842           printf (_("unspecified hard/soft float, "));
13843           break;
13844         case 1:
13845           printf (_("hard float, "));
13846           break;
13847         case 2:
13848           printf (_("soft float, "));
13849           break;
13850         case 3:
13851           printf (_("single-precision hard float, "));
13852           break;
13853         }
13854
13855       switch (val & 0xC)
13856         {
13857         case 0:
13858           printf (_("unspecified long double\n"));
13859           break;
13860         case 4:
13861           printf (_("128-bit IBM long double\n"));
13862           break;
13863         case 8:
13864           printf (_("64-bit long double\n"));
13865           break;
13866         case 12:
13867           printf (_("128-bit IEEE long double\n"));
13868           break;
13869         }
13870       return p;
13871     }
13872
13873   if (tag == Tag_GNU_Power_ABI_Vector)
13874     {
13875       val = read_uleb128 (p, &len, end);
13876       p += len;
13877       printf ("  Tag_GNU_Power_ABI_Vector: ");
13878       if (len == 0)
13879         {
13880           printf (_("<corrupt>\n"));
13881           return p;
13882         }
13883
13884       if (val > 3)
13885         printf ("(%#x), ", val);
13886
13887       switch (val & 3)
13888         {
13889         case 0:
13890           printf (_("unspecified\n"));
13891           break;
13892         case 1:
13893           printf (_("generic\n"));
13894           break;
13895         case 2:
13896           printf ("AltiVec\n");
13897           break;
13898         case 3:
13899           printf ("SPE\n");
13900           break;
13901         }
13902       return p;
13903     }
13904
13905   if (tag == Tag_GNU_Power_ABI_Struct_Return)
13906     {
13907       val = read_uleb128 (p, &len, end);
13908       p += len;
13909       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
13910       if (len == 0)
13911         {
13912           printf (_("<corrupt>\n"));
13913           return p;
13914         }
13915
13916       if (val > 2)
13917         printf ("(%#x), ", val);
13918
13919       switch (val & 3)
13920         {
13921         case 0:
13922           printf (_("unspecified\n"));
13923           break;
13924         case 1:
13925           printf ("r3/r4\n");
13926           break;
13927         case 2:
13928           printf (_("memory\n"));
13929           break;
13930         case 3:
13931           printf ("???\n");
13932           break;
13933         }
13934       return p;
13935     }
13936
13937   return display_tag_value (tag & 1, p, end);
13938 }
13939
13940 static unsigned char *
13941 display_s390_gnu_attribute (unsigned char * p,
13942                             unsigned int tag,
13943                             const unsigned char * const end)
13944 {
13945   unsigned int len;
13946   int val;
13947
13948   if (tag == Tag_GNU_S390_ABI_Vector)
13949     {
13950       val = read_uleb128 (p, &len, end);
13951       p += len;
13952       printf ("  Tag_GNU_S390_ABI_Vector: ");
13953
13954       switch (val)
13955         {
13956         case 0:
13957           printf (_("any\n"));
13958           break;
13959         case 1:
13960           printf (_("software\n"));
13961           break;
13962         case 2:
13963           printf (_("hardware\n"));
13964           break;
13965         default:
13966           printf ("??? (%d)\n", val);
13967           break;
13968         }
13969       return p;
13970    }
13971
13972   return display_tag_value (tag & 1, p, end);
13973 }
13974
13975 static void
13976 display_sparc_hwcaps (unsigned int mask)
13977 {
13978   if (mask)
13979     {
13980       bfd_boolean first = TRUE;
13981
13982       if (mask & ELF_SPARC_HWCAP_MUL32)
13983         fputs ("mul32", stdout), first = FALSE;
13984       if (mask & ELF_SPARC_HWCAP_DIV32)
13985         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
13986       if (mask & ELF_SPARC_HWCAP_FSMULD)
13987         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
13988       if (mask & ELF_SPARC_HWCAP_V8PLUS)
13989         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
13990       if (mask & ELF_SPARC_HWCAP_POPC)
13991         printf ("%spopc", first ? "" : "|"), first = FALSE;
13992       if (mask & ELF_SPARC_HWCAP_VIS)
13993         printf ("%svis", first ? "" : "|"), first = FALSE;
13994       if (mask & ELF_SPARC_HWCAP_VIS2)
13995         printf ("%svis2", first ? "" : "|"), first = FALSE;
13996       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13997         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
13998       if (mask & ELF_SPARC_HWCAP_FMAF)
13999         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14000       if (mask & ELF_SPARC_HWCAP_VIS3)
14001         printf ("%svis3", first ? "" : "|"), first = FALSE;
14002       if (mask & ELF_SPARC_HWCAP_HPC)
14003         printf ("%shpc", first ? "" : "|"), first = FALSE;
14004       if (mask & ELF_SPARC_HWCAP_RANDOM)
14005         printf ("%srandom", first ? "" : "|"), first = FALSE;
14006       if (mask & ELF_SPARC_HWCAP_TRANS)
14007         printf ("%strans", first ? "" : "|"), first = FALSE;
14008       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14009         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14010       if (mask & ELF_SPARC_HWCAP_IMA)
14011         printf ("%sima", first ? "" : "|"), first = FALSE;
14012       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14013         printf ("%scspare", first ? "" : "|"), first = FALSE;
14014     }
14015   else
14016     fputc ('0', stdout);
14017   fputc ('\n', stdout);
14018 }
14019
14020 static void
14021 display_sparc_hwcaps2 (unsigned int mask)
14022 {
14023   if (mask)
14024     {
14025       bfd_boolean first = TRUE;
14026
14027       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14028         fputs ("fjathplus", stdout), first = FALSE;
14029       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14030         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14031       if (mask & ELF_SPARC_HWCAP2_ADP)
14032         printf ("%sadp", first ? "" : "|"), first = FALSE;
14033       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14034         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14035       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14036         printf ("%smwait", first ? "" : "|"), first = FALSE;
14037       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14038         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14039       if (mask & ELF_SPARC_HWCAP2_XMONT)
14040         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14041       if (mask & ELF_SPARC_HWCAP2_NSEC)
14042         printf ("%snsec", first ? "" : "|"), first = FALSE;
14043       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14044         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14045       if (mask & ELF_SPARC_HWCAP2_FJDES)
14046         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14047       if (mask & ELF_SPARC_HWCAP2_FJAES)
14048         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14049     }
14050   else
14051     fputc ('0', stdout);
14052   fputc ('\n', stdout);
14053 }
14054
14055 static unsigned char *
14056 display_sparc_gnu_attribute (unsigned char * p,
14057                              unsigned int tag,
14058                              const unsigned char * const end)
14059 {
14060   unsigned int len;
14061   int val;
14062
14063   if (tag == Tag_GNU_Sparc_HWCAPS)
14064     {
14065       val = read_uleb128 (p, &len, end);
14066       p += len;
14067       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14068       display_sparc_hwcaps (val);
14069       return p;
14070     }
14071   if (tag == Tag_GNU_Sparc_HWCAPS2)
14072     {
14073       val = read_uleb128 (p, &len, end);
14074       p += len;
14075       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14076       display_sparc_hwcaps2 (val);
14077       return p;
14078     }
14079
14080   return display_tag_value (tag, p, end);
14081 }
14082
14083 static void
14084 print_mips_fp_abi_value (unsigned int val)
14085 {
14086   switch (val)
14087     {
14088     case Val_GNU_MIPS_ABI_FP_ANY:
14089       printf (_("Hard or soft float\n"));
14090       break;
14091     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14092       printf (_("Hard float (double precision)\n"));
14093       break;
14094     case Val_GNU_MIPS_ABI_FP_SINGLE:
14095       printf (_("Hard float (single precision)\n"));
14096       break;
14097     case Val_GNU_MIPS_ABI_FP_SOFT:
14098       printf (_("Soft float\n"));
14099       break;
14100     case Val_GNU_MIPS_ABI_FP_OLD_64:
14101       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14102       break;
14103     case Val_GNU_MIPS_ABI_FP_XX:
14104       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14105       break;
14106     case Val_GNU_MIPS_ABI_FP_64:
14107       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14108       break;
14109     case Val_GNU_MIPS_ABI_FP_64A:
14110       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14111       break;
14112     case Val_GNU_MIPS_ABI_FP_NAN2008:
14113       printf (_("NaN 2008 compatibility\n"));
14114       break;
14115     default:
14116       printf ("??? (%d)\n", val);
14117       break;
14118     }
14119 }
14120
14121 static unsigned char *
14122 display_mips_gnu_attribute (unsigned char * p,
14123                             unsigned int tag,
14124                             const unsigned char * const end)
14125 {
14126   if (tag == Tag_GNU_MIPS_ABI_FP)
14127     {
14128       unsigned int len;
14129       unsigned int val;
14130
14131       val = read_uleb128 (p, &len, end);
14132       p += len;
14133       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14134
14135       print_mips_fp_abi_value (val);
14136
14137       return p;
14138    }
14139
14140   if (tag == Tag_GNU_MIPS_ABI_MSA)
14141     {
14142       unsigned int len;
14143       unsigned int val;
14144
14145       val = read_uleb128 (p, &len, end);
14146       p += len;
14147       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14148
14149       switch (val)
14150         {
14151         case Val_GNU_MIPS_ABI_MSA_ANY:
14152           printf (_("Any MSA or not\n"));
14153           break;
14154         case Val_GNU_MIPS_ABI_MSA_128:
14155           printf (_("128-bit MSA\n"));
14156           break;
14157         default:
14158           printf ("??? (%d)\n", val);
14159           break;
14160         }
14161       return p;
14162     }
14163
14164   return display_tag_value (tag & 1, p, end);
14165 }
14166
14167 static unsigned char *
14168 display_tic6x_attribute (unsigned char * p,
14169                          const unsigned char * const end)
14170 {
14171   unsigned int tag;
14172   unsigned int len;
14173   int val;
14174
14175   tag = read_uleb128 (p, &len, end);
14176   p += len;
14177
14178   switch (tag)
14179     {
14180     case Tag_ISA:
14181       val = read_uleb128 (p, &len, end);
14182       p += len;
14183       printf ("  Tag_ISA: ");
14184
14185       switch (val)
14186         {
14187         case C6XABI_Tag_ISA_none:
14188           printf (_("None\n"));
14189           break;
14190         case C6XABI_Tag_ISA_C62X:
14191           printf ("C62x\n");
14192           break;
14193         case C6XABI_Tag_ISA_C67X:
14194           printf ("C67x\n");
14195           break;
14196         case C6XABI_Tag_ISA_C67XP:
14197           printf ("C67x+\n");
14198           break;
14199         case C6XABI_Tag_ISA_C64X:
14200           printf ("C64x\n");
14201           break;
14202         case C6XABI_Tag_ISA_C64XP:
14203           printf ("C64x+\n");
14204           break;
14205         case C6XABI_Tag_ISA_C674X:
14206           printf ("C674x\n");
14207           break;
14208         default:
14209           printf ("??? (%d)\n", val);
14210           break;
14211         }
14212       return p;
14213
14214     case Tag_ABI_wchar_t:
14215       val = read_uleb128 (p, &len, end);
14216       p += len;
14217       printf ("  Tag_ABI_wchar_t: ");
14218       switch (val)
14219         {
14220         case 0:
14221           printf (_("Not used\n"));
14222           break;
14223         case 1:
14224           printf (_("2 bytes\n"));
14225           break;
14226         case 2:
14227           printf (_("4 bytes\n"));
14228           break;
14229         default:
14230           printf ("??? (%d)\n", val);
14231           break;
14232         }
14233       return p;
14234
14235     case Tag_ABI_stack_align_needed:
14236       val = read_uleb128 (p, &len, end);
14237       p += len;
14238       printf ("  Tag_ABI_stack_align_needed: ");
14239       switch (val)
14240         {
14241         case 0:
14242           printf (_("8-byte\n"));
14243           break;
14244         case 1:
14245           printf (_("16-byte\n"));
14246           break;
14247         default:
14248           printf ("??? (%d)\n", val);
14249           break;
14250         }
14251       return p;
14252
14253     case Tag_ABI_stack_align_preserved:
14254       val = read_uleb128 (p, &len, end);
14255       p += len;
14256       printf ("  Tag_ABI_stack_align_preserved: ");
14257       switch (val)
14258         {
14259         case 0:
14260           printf (_("8-byte\n"));
14261           break;
14262         case 1:
14263           printf (_("16-byte\n"));
14264           break;
14265         default:
14266           printf ("??? (%d)\n", val);
14267           break;
14268         }
14269       return p;
14270
14271     case Tag_ABI_DSBT:
14272       val = read_uleb128 (p, &len, end);
14273       p += len;
14274       printf ("  Tag_ABI_DSBT: ");
14275       switch (val)
14276         {
14277         case 0:
14278           printf (_("DSBT addressing not used\n"));
14279           break;
14280         case 1:
14281           printf (_("DSBT addressing used\n"));
14282           break;
14283         default:
14284           printf ("??? (%d)\n", val);
14285           break;
14286         }
14287       return p;
14288
14289     case Tag_ABI_PID:
14290       val = read_uleb128 (p, &len, end);
14291       p += len;
14292       printf ("  Tag_ABI_PID: ");
14293       switch (val)
14294         {
14295         case 0:
14296           printf (_("Data addressing position-dependent\n"));
14297           break;
14298         case 1:
14299           printf (_("Data addressing position-independent, GOT near DP\n"));
14300           break;
14301         case 2:
14302           printf (_("Data addressing position-independent, GOT far from DP\n"));
14303           break;
14304         default:
14305           printf ("??? (%d)\n", val);
14306           break;
14307         }
14308       return p;
14309
14310     case Tag_ABI_PIC:
14311       val = read_uleb128 (p, &len, end);
14312       p += len;
14313       printf ("  Tag_ABI_PIC: ");
14314       switch (val)
14315         {
14316         case 0:
14317           printf (_("Code addressing position-dependent\n"));
14318           break;
14319         case 1:
14320           printf (_("Code addressing position-independent\n"));
14321           break;
14322         default:
14323           printf ("??? (%d)\n", val);
14324           break;
14325         }
14326       return p;
14327
14328     case Tag_ABI_array_object_alignment:
14329       val = read_uleb128 (p, &len, end);
14330       p += len;
14331       printf ("  Tag_ABI_array_object_alignment: ");
14332       switch (val)
14333         {
14334         case 0:
14335           printf (_("8-byte\n"));
14336           break;
14337         case 1:
14338           printf (_("4-byte\n"));
14339           break;
14340         case 2:
14341           printf (_("16-byte\n"));
14342           break;
14343         default:
14344           printf ("??? (%d)\n", val);
14345           break;
14346         }
14347       return p;
14348
14349     case Tag_ABI_array_object_align_expected:
14350       val = read_uleb128 (p, &len, end);
14351       p += len;
14352       printf ("  Tag_ABI_array_object_align_expected: ");
14353       switch (val)
14354         {
14355         case 0:
14356           printf (_("8-byte\n"));
14357           break;
14358         case 1:
14359           printf (_("4-byte\n"));
14360           break;
14361         case 2:
14362           printf (_("16-byte\n"));
14363           break;
14364         default:
14365           printf ("??? (%d)\n", val);
14366           break;
14367         }
14368       return p;
14369
14370     case Tag_ABI_compatibility:
14371       {
14372         val = read_uleb128 (p, &len, end);
14373         p += len;
14374         printf ("  Tag_ABI_compatibility: ");
14375         printf (_("flag = %d, vendor = "), val);
14376         if (p < end - 1)
14377           {
14378             size_t maxlen = (end - p) - 1;
14379
14380             print_symbol ((int) maxlen, (const char *) p);
14381             p += strnlen ((char *) p, maxlen) + 1;
14382           }
14383         else
14384           {
14385             printf (_("<corrupt>"));
14386             p = (unsigned char *) end;
14387           }
14388         putchar ('\n');
14389         return p;
14390       }
14391
14392     case Tag_ABI_conformance:
14393       {
14394         printf ("  Tag_ABI_conformance: \"");
14395         if (p < end - 1)
14396           {
14397             size_t maxlen = (end - p) - 1;
14398
14399             print_symbol ((int) maxlen, (const char *) p);
14400             p += strnlen ((char *) p, maxlen) + 1;
14401           }
14402         else
14403           {
14404             printf (_("<corrupt>"));
14405             p = (unsigned char *) end;
14406           }
14407         printf ("\"\n");
14408         return p;
14409       }
14410     }
14411
14412   return display_tag_value (tag, p, end);
14413 }
14414
14415 static void
14416 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14417 {
14418   unsigned long addr = 0;
14419   size_t bytes = end - p;
14420
14421   assert (end > p);
14422   while (bytes)
14423     {
14424       int j;
14425       int k;
14426       int lbytes = (bytes > 16 ? 16 : bytes);
14427
14428       printf ("  0x%8.8lx ", addr);
14429
14430       for (j = 0; j < 16; j++)
14431         {
14432           if (j < lbytes)
14433             printf ("%2.2x", p[j]);
14434           else
14435             printf ("  ");
14436
14437           if ((j & 3) == 3)
14438             printf (" ");
14439         }
14440
14441       for (j = 0; j < lbytes; j++)
14442         {
14443           k = p[j];
14444           if (k >= ' ' && k < 0x7f)
14445             printf ("%c", k);
14446           else
14447             printf (".");
14448         }
14449
14450       putchar ('\n');
14451
14452       p  += lbytes;
14453       bytes -= lbytes;
14454       addr += lbytes;
14455     }
14456
14457   putchar ('\n');
14458 }
14459
14460 static unsigned char *
14461 display_msp430x_attribute (unsigned char * p,
14462                            const unsigned char * const end)
14463 {
14464   unsigned int len;
14465   unsigned int val;
14466   unsigned int tag;
14467
14468   tag = read_uleb128 (p, & len, end);
14469   p += len;
14470
14471   switch (tag)
14472     {
14473     case OFBA_MSPABI_Tag_ISA:
14474       val = read_uleb128 (p, &len, end);
14475       p += len;
14476       printf ("  Tag_ISA: ");
14477       switch (val)
14478         {
14479         case 0: printf (_("None\n")); break;
14480         case 1: printf (_("MSP430\n")); break;
14481         case 2: printf (_("MSP430X\n")); break;
14482         default: printf ("??? (%d)\n", val); break;
14483         }
14484       break;
14485
14486     case OFBA_MSPABI_Tag_Code_Model:
14487       val = read_uleb128 (p, &len, end);
14488       p += len;
14489       printf ("  Tag_Code_Model: ");
14490       switch (val)
14491         {
14492         case 0: printf (_("None\n")); break;
14493         case 1: printf (_("Small\n")); break;
14494         case 2: printf (_("Large\n")); break;
14495         default: printf ("??? (%d)\n", val); break;
14496         }
14497       break;
14498
14499     case OFBA_MSPABI_Tag_Data_Model:
14500       val = read_uleb128 (p, &len, end);
14501       p += len;
14502       printf ("  Tag_Data_Model: ");
14503       switch (val)
14504         {
14505         case 0: printf (_("None\n")); break;
14506         case 1: printf (_("Small\n")); break;
14507         case 2: printf (_("Large\n")); break;
14508         case 3: printf (_("Restricted Large\n")); break;
14509         default: printf ("??? (%d)\n", val); break;
14510         }
14511       break;
14512
14513     default:
14514       printf (_("  <unknown tag %d>: "), tag);
14515
14516       if (tag & 1)
14517         {
14518           putchar ('"');
14519           if (p < end - 1)
14520             {
14521               size_t maxlen = (end - p) - 1;
14522
14523               print_symbol ((int) maxlen, (const char *) p);
14524               p += strnlen ((char *) p, maxlen) + 1;
14525             }
14526           else
14527             {
14528               printf (_("<corrupt>"));
14529               p = (unsigned char *) end;
14530             }
14531           printf ("\"\n");
14532         }
14533       else
14534         {
14535           val = read_uleb128 (p, &len, end);
14536           p += len;
14537           printf ("%d (0x%x)\n", val, val);
14538         }
14539       break;
14540    }
14541
14542   assert (p <= end);
14543   return p;
14544 }
14545
14546 static bfd_boolean
14547 process_attributes (FILE * file,
14548                     const char * public_name,
14549                     unsigned int proc_type,
14550                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14551                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14552 {
14553   Elf_Internal_Shdr * sect;
14554   unsigned i;
14555   bfd_boolean res = TRUE;
14556
14557   /* Find the section header so that we get the size.  */
14558   for (i = 0, sect = section_headers;
14559        i < elf_header.e_shnum;
14560        i++, sect++)
14561     {
14562       unsigned char * contents;
14563       unsigned char * p;
14564
14565       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14566         continue;
14567
14568       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14569                                              sect->sh_size, _("attributes"));
14570       if (contents == NULL)
14571         {
14572           res = FALSE;
14573           continue;
14574         }
14575
14576       p = contents;
14577       /* The first character is the version of the attributes.
14578          Currently only version 1, (aka 'A') is recognised here.  */
14579       if (*p != 'A')
14580         {
14581           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14582           res = FALSE;
14583         }
14584       else
14585         {
14586           bfd_vma section_len;
14587
14588           section_len = sect->sh_size - 1;
14589           p++;
14590
14591           while (section_len > 0)
14592             {
14593               bfd_vma attr_len;
14594               unsigned int namelen;
14595               bfd_boolean public_section;
14596               bfd_boolean gnu_section;
14597
14598               if (section_len <= 4)
14599                 {
14600                   error (_("Tag section ends prematurely\n"));
14601                   res = FALSE;
14602                   break;
14603                 }
14604               attr_len = byte_get (p, 4);
14605               p += 4;
14606
14607               if (attr_len > section_len)
14608                 {
14609                   error (_("Bad attribute length (%u > %u)\n"),
14610                           (unsigned) attr_len, (unsigned) section_len);
14611                   attr_len = section_len;
14612                   res = FALSE;
14613                 }
14614               /* PR 17531: file: 001-101425-0.004  */
14615               else if (attr_len < 5)
14616                 {
14617                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14618                   res = FALSE;
14619                   break;
14620                 }
14621
14622               section_len -= attr_len;
14623               attr_len -= 4;
14624
14625               namelen = strnlen ((char *) p, attr_len) + 1;
14626               if (namelen == 0 || namelen >= attr_len)
14627                 {
14628                   error (_("Corrupt attribute section name\n"));
14629                   res = FALSE;
14630                   break;
14631                 }
14632
14633               printf (_("Attribute Section: "));
14634               print_symbol (INT_MAX, (const char *) p);
14635               putchar ('\n');
14636
14637               if (public_name && streq ((char *) p, public_name))
14638                 public_section = TRUE;
14639               else
14640                 public_section = FALSE;
14641
14642               if (streq ((char *) p, "gnu"))
14643                 gnu_section = TRUE;
14644               else
14645                 gnu_section = FALSE;
14646
14647               p += namelen;
14648               attr_len -= namelen;
14649
14650               while (attr_len > 0 && p < contents + sect->sh_size)
14651                 {
14652                   int tag;
14653                   int val;
14654                   bfd_vma size;
14655                   unsigned char * end;
14656
14657                   /* PR binutils/17531: Safe handling of corrupt files.  */
14658                   if (attr_len < 6)
14659                     {
14660                       error (_("Unused bytes at end of section\n"));
14661                       res = FALSE;
14662                       section_len = 0;
14663                       break;
14664                     }
14665
14666                   tag = *(p++);
14667                   size = byte_get (p, 4);
14668                   if (size > attr_len)
14669                     {
14670                       error (_("Bad subsection length (%u > %u)\n"),
14671                               (unsigned) size, (unsigned) attr_len);
14672                       res = FALSE;
14673                       size = attr_len;
14674                     }
14675                   /* PR binutils/17531: Safe handling of corrupt files.  */
14676                   if (size < 6)
14677                     {
14678                       error (_("Bad subsection length (%u < 6)\n"),
14679                               (unsigned) size);
14680                       res = FALSE;
14681                       section_len = 0;
14682                       break;
14683                     }
14684
14685                   attr_len -= size;
14686                   end = p + size - 1;
14687                   assert (end <= contents + sect->sh_size);
14688                   p += 4;
14689
14690                   switch (tag)
14691                     {
14692                     case 1:
14693                       printf (_("File Attributes\n"));
14694                       break;
14695                     case 2:
14696                       printf (_("Section Attributes:"));
14697                       goto do_numlist;
14698                     case 3:
14699                       printf (_("Symbol Attributes:"));
14700                       /* Fall through.  */
14701                     do_numlist:
14702                       for (;;)
14703                         {
14704                           unsigned int j;
14705
14706                           val = read_uleb128 (p, &j, end);
14707                           p += j;
14708                           if (val == 0)
14709                             break;
14710                           printf (" %d", val);
14711                         }
14712                       printf ("\n");
14713                       break;
14714                     default:
14715                       printf (_("Unknown tag: %d\n"), tag);
14716                       public_section = FALSE;
14717                       break;
14718                     }
14719
14720                   if (public_section && display_pub_attribute != NULL)
14721                     {
14722                       while (p < end)
14723                         p = display_pub_attribute (p, end);
14724                       assert (p == end);
14725                     }
14726                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14727                     {
14728                       while (p < end)
14729                         p = display_gnu_attribute (p,
14730                                                    display_proc_gnu_attribute,
14731                                                    end);
14732                       assert (p == end);
14733                     }
14734                   else if (p < end)
14735                     {
14736                       printf (_("  Unknown attribute:\n"));
14737                       display_raw_attribute (p, end);
14738                       p = end;
14739                     }
14740                   else
14741                     attr_len = 0;
14742                 }
14743             }
14744         }
14745
14746       free (contents);
14747     }
14748
14749   return res;
14750 }
14751
14752 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14753    Print the Address, Access and Initial fields of an entry at VMA ADDR
14754    and return the VMA of the next entry, or -1 if there was a problem.
14755    Does not read from DATA_END or beyond.  */
14756
14757 static bfd_vma
14758 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14759                       unsigned char * data_end)
14760 {
14761   printf ("  ");
14762   print_vma (addr, LONG_HEX);
14763   printf (" ");
14764   if (addr < pltgot + 0xfff0)
14765     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14766   else
14767     printf ("%10s", "");
14768   printf (" ");
14769   if (data == NULL)
14770     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14771   else
14772     {
14773       bfd_vma entry;
14774       unsigned char * from = data + addr - pltgot;
14775
14776       if (from + (is_32bit_elf ? 4 : 8) > data_end)
14777         {
14778           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14779           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14780           return (bfd_vma) -1;
14781         }
14782       else
14783         {
14784           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14785           print_vma (entry, LONG_HEX);
14786         }
14787     }
14788   return addr + (is_32bit_elf ? 4 : 8);
14789 }
14790
14791 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14792    PLTGOT.  Print the Address and Initial fields of an entry at VMA
14793    ADDR and return the VMA of the next entry.  */
14794
14795 static bfd_vma
14796 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14797 {
14798   printf ("  ");
14799   print_vma (addr, LONG_HEX);
14800   printf (" ");
14801   if (data == NULL)
14802     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14803   else
14804     {
14805       bfd_vma entry;
14806
14807       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14808       print_vma (entry, LONG_HEX);
14809     }
14810   return addr + (is_32bit_elf ? 4 : 8);
14811 }
14812
14813 static void
14814 print_mips_ases (unsigned int mask)
14815 {
14816   if (mask & AFL_ASE_DSP)
14817     fputs ("\n\tDSP ASE", stdout);
14818   if (mask & AFL_ASE_DSPR2)
14819     fputs ("\n\tDSP R2 ASE", stdout);
14820   if (mask & AFL_ASE_DSPR3)
14821     fputs ("\n\tDSP R3 ASE", stdout);
14822   if (mask & AFL_ASE_EVA)
14823     fputs ("\n\tEnhanced VA Scheme", stdout);
14824   if (mask & AFL_ASE_MCU)
14825     fputs ("\n\tMCU (MicroController) ASE", stdout);
14826   if (mask & AFL_ASE_MDMX)
14827     fputs ("\n\tMDMX ASE", stdout);
14828   if (mask & AFL_ASE_MIPS3D)
14829     fputs ("\n\tMIPS-3D ASE", stdout);
14830   if (mask & AFL_ASE_MT)
14831     fputs ("\n\tMT ASE", stdout);
14832   if (mask & AFL_ASE_SMARTMIPS)
14833     fputs ("\n\tSmartMIPS ASE", stdout);
14834   if (mask & AFL_ASE_VIRT)
14835     fputs ("\n\tVZ ASE", stdout);
14836   if (mask & AFL_ASE_MSA)
14837     fputs ("\n\tMSA ASE", stdout);
14838   if (mask & AFL_ASE_MIPS16)
14839     fputs ("\n\tMIPS16 ASE", stdout);
14840   if (mask & AFL_ASE_MICROMIPS)
14841     fputs ("\n\tMICROMIPS ASE", stdout);
14842   if (mask & AFL_ASE_XPA)
14843     fputs ("\n\tXPA ASE", stdout);
14844   if (mask == 0)
14845     fprintf (stdout, "\n\t%s", _("None"));
14846   else if ((mask & ~AFL_ASE_MASK) != 0)
14847     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14848 }
14849
14850 static void
14851 print_mips_isa_ext (unsigned int isa_ext)
14852 {
14853   switch (isa_ext)
14854     {
14855     case 0:
14856       fputs (_("None"), stdout);
14857       break;
14858     case AFL_EXT_XLR:
14859       fputs ("RMI XLR", stdout);
14860       break;
14861     case AFL_EXT_OCTEON3:
14862       fputs ("Cavium Networks Octeon3", stdout);
14863       break;
14864     case AFL_EXT_OCTEON2:
14865       fputs ("Cavium Networks Octeon2", stdout);
14866       break;
14867     case AFL_EXT_OCTEONP:
14868       fputs ("Cavium Networks OcteonP", stdout);
14869       break;
14870     case AFL_EXT_LOONGSON_3A:
14871       fputs ("Loongson 3A", stdout);
14872       break;
14873     case AFL_EXT_OCTEON:
14874       fputs ("Cavium Networks Octeon", stdout);
14875       break;
14876     case AFL_EXT_5900:
14877       fputs ("Toshiba R5900", stdout);
14878       break;
14879     case AFL_EXT_4650:
14880       fputs ("MIPS R4650", stdout);
14881       break;
14882     case AFL_EXT_4010:
14883       fputs ("LSI R4010", stdout);
14884       break;
14885     case AFL_EXT_4100:
14886       fputs ("NEC VR4100", stdout);
14887       break;
14888     case AFL_EXT_3900:
14889       fputs ("Toshiba R3900", stdout);
14890       break;
14891     case AFL_EXT_10000:
14892       fputs ("MIPS R10000", stdout);
14893       break;
14894     case AFL_EXT_SB1:
14895       fputs ("Broadcom SB-1", stdout);
14896       break;
14897     case AFL_EXT_4111:
14898       fputs ("NEC VR4111/VR4181", stdout);
14899       break;
14900     case AFL_EXT_4120:
14901       fputs ("NEC VR4120", stdout);
14902       break;
14903     case AFL_EXT_5400:
14904       fputs ("NEC VR5400", stdout);
14905       break;
14906     case AFL_EXT_5500:
14907       fputs ("NEC VR5500", stdout);
14908       break;
14909     case AFL_EXT_LOONGSON_2E:
14910       fputs ("ST Microelectronics Loongson 2E", stdout);
14911       break;
14912     case AFL_EXT_LOONGSON_2F:
14913       fputs ("ST Microelectronics Loongson 2F", stdout);
14914       break;
14915     default:
14916       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14917     }
14918 }
14919
14920 static signed int
14921 get_mips_reg_size (int reg_size)
14922 {
14923   return (reg_size == AFL_REG_NONE) ? 0
14924          : (reg_size == AFL_REG_32) ? 32
14925          : (reg_size == AFL_REG_64) ? 64
14926          : (reg_size == AFL_REG_128) ? 128
14927          : -1;
14928 }
14929
14930 static bfd_boolean
14931 process_mips_specific (FILE * file)
14932 {
14933   Elf_Internal_Dyn * entry;
14934   Elf_Internal_Shdr *sect = NULL;
14935   size_t liblist_offset = 0;
14936   size_t liblistno = 0;
14937   size_t conflictsno = 0;
14938   size_t options_offset = 0;
14939   size_t conflicts_offset = 0;
14940   size_t pltrelsz = 0;
14941   size_t pltrel = 0;
14942   bfd_vma pltgot = 0;
14943   bfd_vma mips_pltgot = 0;
14944   bfd_vma jmprel = 0;
14945   bfd_vma local_gotno = 0;
14946   bfd_vma gotsym = 0;
14947   bfd_vma symtabno = 0;
14948   bfd_boolean res = TRUE;
14949
14950   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14951                             display_mips_gnu_attribute))
14952     res = FALSE;
14953
14954   sect = find_section (".MIPS.abiflags");
14955
14956   if (sect != NULL)
14957     {
14958       Elf_External_ABIFlags_v0 *abiflags_ext;
14959       Elf_Internal_ABIFlags_v0 abiflags_in;
14960
14961       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14962         {
14963           error (_("Corrupt MIPS ABI Flags section.\n"));
14964           res = FALSE;
14965         }
14966       else
14967         {
14968           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14969                                    sect->sh_size, _("MIPS ABI Flags section"));
14970           if (abiflags_ext)
14971             {
14972               abiflags_in.version = BYTE_GET (abiflags_ext->version);
14973               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14974               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14975               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14976               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14977               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14978               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14979               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14980               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14981               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14982               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14983
14984               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14985               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14986               if (abiflags_in.isa_rev > 1)
14987                 printf ("r%d", abiflags_in.isa_rev);
14988               printf ("\nGPR size: %d",
14989                       get_mips_reg_size (abiflags_in.gpr_size));
14990               printf ("\nCPR1 size: %d",
14991                       get_mips_reg_size (abiflags_in.cpr1_size));
14992               printf ("\nCPR2 size: %d",
14993                       get_mips_reg_size (abiflags_in.cpr2_size));
14994               fputs ("\nFP ABI: ", stdout);
14995               print_mips_fp_abi_value (abiflags_in.fp_abi);
14996               fputs ("ISA Extension: ", stdout);
14997               print_mips_isa_ext (abiflags_in.isa_ext);
14998               fputs ("\nASEs:", stdout);
14999               print_mips_ases (abiflags_in.ases);
15000               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15001               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15002               fputc ('\n', stdout);
15003               free (abiflags_ext);
15004             }
15005         }
15006     }
15007
15008   /* We have a lot of special sections.  Thanks SGI!  */
15009   if (dynamic_section == NULL)
15010     /* No information available.  */
15011     return res;
15012
15013   for (entry = dynamic_section;
15014        /* PR 17531 file: 012-50589-0.004.  */
15015        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15016        ++entry)
15017     switch (entry->d_tag)
15018       {
15019       case DT_MIPS_LIBLIST:
15020         liblist_offset
15021           = offset_from_vma (file, entry->d_un.d_val,
15022                              liblistno * sizeof (Elf32_External_Lib));
15023         break;
15024       case DT_MIPS_LIBLISTNO:
15025         liblistno = entry->d_un.d_val;
15026         break;
15027       case DT_MIPS_OPTIONS:
15028         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15029         break;
15030       case DT_MIPS_CONFLICT:
15031         conflicts_offset
15032           = offset_from_vma (file, entry->d_un.d_val,
15033                              conflictsno * sizeof (Elf32_External_Conflict));
15034         break;
15035       case DT_MIPS_CONFLICTNO:
15036         conflictsno = entry->d_un.d_val;
15037         break;
15038       case DT_PLTGOT:
15039         pltgot = entry->d_un.d_ptr;
15040         break;
15041       case DT_MIPS_LOCAL_GOTNO:
15042         local_gotno = entry->d_un.d_val;
15043         break;
15044       case DT_MIPS_GOTSYM:
15045         gotsym = entry->d_un.d_val;
15046         break;
15047       case DT_MIPS_SYMTABNO:
15048         symtabno = entry->d_un.d_val;
15049         break;
15050       case DT_MIPS_PLTGOT:
15051         mips_pltgot = entry->d_un.d_ptr;
15052         break;
15053       case DT_PLTREL:
15054         pltrel = entry->d_un.d_val;
15055         break;
15056       case DT_PLTRELSZ:
15057         pltrelsz = entry->d_un.d_val;
15058         break;
15059       case DT_JMPREL:
15060         jmprel = entry->d_un.d_ptr;
15061         break;
15062       default:
15063         break;
15064       }
15065
15066   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15067     {
15068       Elf32_External_Lib * elib;
15069       size_t cnt;
15070
15071       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15072                                               liblistno,
15073                                               sizeof (Elf32_External_Lib),
15074                                               _("liblist section data"));
15075       if (elib)
15076         {
15077           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15078                   (unsigned long) liblistno);
15079           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15080                  stdout);
15081
15082           for (cnt = 0; cnt < liblistno; ++cnt)
15083             {
15084               Elf32_Lib liblist;
15085               time_t atime;
15086               char timebuf[128];
15087               struct tm * tmp;
15088
15089               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15090               atime = BYTE_GET (elib[cnt].l_time_stamp);
15091               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15092               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15093               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15094
15095               tmp = gmtime (&atime);
15096               snprintf (timebuf, sizeof (timebuf),
15097                         "%04u-%02u-%02uT%02u:%02u:%02u",
15098                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15099                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15100
15101               printf ("%3lu: ", (unsigned long) cnt);
15102               if (VALID_DYNAMIC_NAME (liblist.l_name))
15103                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15104               else
15105                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15106               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15107                       liblist.l_version);
15108
15109               if (liblist.l_flags == 0)
15110                 puts (_(" NONE"));
15111               else
15112                 {
15113                   static const struct
15114                   {
15115                     const char * name;
15116                     int bit;
15117                   }
15118                   l_flags_vals[] =
15119                   {
15120                     { " EXACT_MATCH", LL_EXACT_MATCH },
15121                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15122                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15123                     { " EXPORTS", LL_EXPORTS },
15124                     { " DELAY_LOAD", LL_DELAY_LOAD },
15125                     { " DELTA", LL_DELTA }
15126                   };
15127                   int flags = liblist.l_flags;
15128                   size_t fcnt;
15129
15130                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15131                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15132                       {
15133                         fputs (l_flags_vals[fcnt].name, stdout);
15134                         flags ^= l_flags_vals[fcnt].bit;
15135                       }
15136                   if (flags != 0)
15137                     printf (" %#x", (unsigned int) flags);
15138
15139                   puts ("");
15140                 }
15141             }
15142
15143           free (elib);
15144         }
15145       else
15146         res = FALSE;
15147     }
15148
15149   if (options_offset != 0)
15150     {
15151       Elf_External_Options * eopt;
15152       Elf_Internal_Options * iopt;
15153       Elf_Internal_Options * option;
15154       size_t offset;
15155       int cnt;
15156       sect = section_headers;
15157
15158       /* Find the section header so that we get the size.  */
15159       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15160       /* PR 17533 file: 012-277276-0.004.  */
15161       if (sect == NULL)
15162         {
15163           error (_("No MIPS_OPTIONS header found\n"));
15164           return FALSE;
15165         }
15166
15167       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15168                                                 sect->sh_size, _("options"));
15169       if (eopt)
15170         {
15171           iopt = (Elf_Internal_Options *)
15172               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15173           if (iopt == NULL)
15174             {
15175               error (_("Out of memory allocating space for MIPS options\n"));
15176               return FALSE;
15177             }
15178
15179           offset = cnt = 0;
15180           option = iopt;
15181
15182           while (offset <= sect->sh_size - sizeof (* eopt))
15183             {
15184               Elf_External_Options * eoption;
15185
15186               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15187
15188               option->kind = BYTE_GET (eoption->kind);
15189               option->size = BYTE_GET (eoption->size);
15190               option->section = BYTE_GET (eoption->section);
15191               option->info = BYTE_GET (eoption->info);
15192
15193               /* PR 17531: file: ffa0fa3b.  */
15194               if (option->size < sizeof (* eopt)
15195                   || offset + option->size > sect->sh_size)
15196                 {
15197                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15198                   return FALSE;
15199                 }
15200               offset += option->size;
15201
15202               ++option;
15203               ++cnt;
15204             }
15205
15206           printf (_("\nSection '%s' contains %d entries:\n"),
15207                   printable_section_name (sect), cnt);
15208
15209           option = iopt;
15210           offset = 0;
15211
15212           while (cnt-- > 0)
15213             {
15214               size_t len;
15215
15216               switch (option->kind)
15217                 {
15218                 case ODK_NULL:
15219                   /* This shouldn't happen.  */
15220                   printf (" NULL       %d %lx", option->section, option->info);
15221                   break;
15222                 case ODK_REGINFO:
15223                   printf (" REGINFO    ");
15224                   if (elf_header.e_machine == EM_MIPS)
15225                     {
15226                       /* 32bit form.  */
15227                       Elf32_External_RegInfo * ereg;
15228                       Elf32_RegInfo reginfo;
15229
15230                       ereg = (Elf32_External_RegInfo *) (option + 1);
15231                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15232                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15233                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15234                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15235                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15236                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15237
15238                       printf ("GPR %08lx  GP 0x%lx\n",
15239                               reginfo.ri_gprmask,
15240                               (unsigned long) reginfo.ri_gp_value);
15241                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15242                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15243                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15244                     }
15245                   else
15246                     {
15247                       /* 64 bit form.  */
15248                       Elf64_External_RegInfo * ereg;
15249                       Elf64_Internal_RegInfo reginfo;
15250
15251                       ereg = (Elf64_External_RegInfo *) (option + 1);
15252                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15253                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15254                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15255                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15256                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15257                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15258
15259                       printf ("GPR %08lx  GP 0x",
15260                               reginfo.ri_gprmask);
15261                       printf_vma (reginfo.ri_gp_value);
15262                       printf ("\n");
15263
15264                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15265                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15266                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15267                     }
15268                   ++option;
15269                   continue;
15270                 case ODK_EXCEPTIONS:
15271                   fputs (" EXCEPTIONS fpe_min(", stdout);
15272                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15273                   fputs (") fpe_max(", stdout);
15274                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15275                   fputs (")", stdout);
15276
15277                   if (option->info & OEX_PAGE0)
15278                     fputs (" PAGE0", stdout);
15279                   if (option->info & OEX_SMM)
15280                     fputs (" SMM", stdout);
15281                   if (option->info & OEX_FPDBUG)
15282                     fputs (" FPDBUG", stdout);
15283                   if (option->info & OEX_DISMISS)
15284                     fputs (" DISMISS", stdout);
15285                   break;
15286                 case ODK_PAD:
15287                   fputs (" PAD       ", stdout);
15288                   if (option->info & OPAD_PREFIX)
15289                     fputs (" PREFIX", stdout);
15290                   if (option->info & OPAD_POSTFIX)
15291                     fputs (" POSTFIX", stdout);
15292                   if (option->info & OPAD_SYMBOL)
15293                     fputs (" SYMBOL", stdout);
15294                   break;
15295                 case ODK_HWPATCH:
15296                   fputs (" HWPATCH   ", stdout);
15297                   if (option->info & OHW_R4KEOP)
15298                     fputs (" R4KEOP", stdout);
15299                   if (option->info & OHW_R8KPFETCH)
15300                     fputs (" R8KPFETCH", stdout);
15301                   if (option->info & OHW_R5KEOP)
15302                     fputs (" R5KEOP", stdout);
15303                   if (option->info & OHW_R5KCVTL)
15304                     fputs (" R5KCVTL", stdout);
15305                   break;
15306                 case ODK_FILL:
15307                   fputs (" FILL       ", stdout);
15308                   /* XXX Print content of info word?  */
15309                   break;
15310                 case ODK_TAGS:
15311                   fputs (" TAGS       ", stdout);
15312                   /* XXX Print content of info word?  */
15313                   break;
15314                 case ODK_HWAND:
15315                   fputs (" HWAND     ", stdout);
15316                   if (option->info & OHWA0_R4KEOP_CHECKED)
15317                     fputs (" R4KEOP_CHECKED", stdout);
15318                   if (option->info & OHWA0_R4KEOP_CLEAN)
15319                     fputs (" R4KEOP_CLEAN", stdout);
15320                   break;
15321                 case ODK_HWOR:
15322                   fputs (" HWOR      ", stdout);
15323                   if (option->info & OHWA0_R4KEOP_CHECKED)
15324                     fputs (" R4KEOP_CHECKED", stdout);
15325                   if (option->info & OHWA0_R4KEOP_CLEAN)
15326                     fputs (" R4KEOP_CLEAN", stdout);
15327                   break;
15328                 case ODK_GP_GROUP:
15329                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15330                           option->info & OGP_GROUP,
15331                           (option->info & OGP_SELF) >> 16);
15332                   break;
15333                 case ODK_IDENT:
15334                   printf (" IDENT     %#06lx  self-contained %#06lx",
15335                           option->info & OGP_GROUP,
15336                           (option->info & OGP_SELF) >> 16);
15337                   break;
15338                 default:
15339                   /* This shouldn't happen.  */
15340                   printf (" %3d ???     %d %lx",
15341                           option->kind, option->section, option->info);
15342                   break;
15343                 }
15344
15345               len = sizeof (* eopt);
15346               while (len < option->size)
15347                 {
15348                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15349
15350                   if (ISPRINT (datum))
15351                     printf ("%c", datum);
15352                   else
15353                     printf ("\\%03o", datum);
15354                   len ++;
15355                 }
15356               fputs ("\n", stdout);
15357
15358               offset += option->size;
15359               ++option;
15360             }
15361
15362           free (eopt);
15363         }
15364       else
15365         res = FALSE;
15366     }
15367
15368   if (conflicts_offset != 0 && conflictsno != 0)
15369     {
15370       Elf32_Conflict * iconf;
15371       size_t cnt;
15372
15373       if (dynamic_symbols == NULL)
15374         {
15375           error (_("conflict list found without a dynamic symbol table\n"));
15376           return FALSE;
15377         }
15378
15379       /* PR 21345 - print a slightly more helpful error message
15380          if we are sure that the cmalloc will fail.  */
15381       if (conflictsno * sizeof (* iconf) > current_file_size)
15382         {
15383           error (_("Overlarge number of conflicts detected: %lx\n"),
15384                  (long) conflictsno);
15385           return FALSE;
15386         }
15387
15388       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15389       if (iconf == NULL)
15390         {
15391           error (_("Out of memory allocating space for dynamic conflicts\n"));
15392           return FALSE;
15393         }
15394
15395       if (is_32bit_elf)
15396         {
15397           Elf32_External_Conflict * econf32;
15398
15399           econf32 = (Elf32_External_Conflict *)
15400               get_data (NULL, file, conflicts_offset, conflictsno,
15401                         sizeof (* econf32), _("conflict"));
15402           if (!econf32)
15403             return FALSE;
15404
15405           for (cnt = 0; cnt < conflictsno; ++cnt)
15406             iconf[cnt] = BYTE_GET (econf32[cnt]);
15407
15408           free (econf32);
15409         }
15410       else
15411         {
15412           Elf64_External_Conflict * econf64;
15413
15414           econf64 = (Elf64_External_Conflict *)
15415               get_data (NULL, file, conflicts_offset, conflictsno,
15416                         sizeof (* econf64), _("conflict"));
15417           if (!econf64)
15418             return FALSE;
15419
15420           for (cnt = 0; cnt < conflictsno; ++cnt)
15421             iconf[cnt] = BYTE_GET (econf64[cnt]);
15422
15423           free (econf64);
15424         }
15425
15426       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15427               (unsigned long) conflictsno);
15428       puts (_("  Num:    Index       Value  Name"));
15429
15430       for (cnt = 0; cnt < conflictsno; ++cnt)
15431         {
15432           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15433
15434           if (iconf[cnt] >= num_dynamic_syms)
15435             printf (_("<corrupt symbol index>"));
15436           else
15437             {
15438               Elf_Internal_Sym * psym;
15439
15440               psym = & dynamic_symbols[iconf[cnt]];
15441               print_vma (psym->st_value, FULL_HEX);
15442               putchar (' ');
15443               if (VALID_DYNAMIC_NAME (psym->st_name))
15444                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15445               else
15446                 printf (_("<corrupt: %14ld>"), psym->st_name);
15447             }
15448           putchar ('\n');
15449         }
15450
15451       free (iconf);
15452     }
15453
15454   if (pltgot != 0 && local_gotno != 0)
15455     {
15456       bfd_vma ent, local_end, global_end;
15457       size_t i, offset;
15458       unsigned char * data;
15459       unsigned char * data_end;
15460       int addr_size;
15461
15462       ent = pltgot;
15463       addr_size = (is_32bit_elf ? 4 : 8);
15464       local_end = pltgot + local_gotno * addr_size;
15465
15466       /* PR binutils/17533 file: 012-111227-0.004  */
15467       if (symtabno < gotsym)
15468         {
15469           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15470                  (unsigned long) gotsym, (unsigned long) symtabno);
15471           return FALSE;
15472         }
15473
15474       global_end = local_end + (symtabno - gotsym) * addr_size;
15475       /* PR 17531: file: 54c91a34.  */
15476       if (global_end < local_end)
15477         {
15478           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15479           return FALSE;
15480         }
15481
15482       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15483       data = (unsigned char *) get_data (NULL, file, offset,
15484                                          global_end - pltgot, 1,
15485                                          _("Global Offset Table data"));
15486       if (data == NULL)
15487         return FALSE;
15488       data_end = data + (global_end - pltgot);
15489
15490       printf (_("\nPrimary GOT:\n"));
15491       printf (_(" Canonical gp value: "));
15492       print_vma (pltgot + 0x7ff0, LONG_HEX);
15493       printf ("\n\n");
15494
15495       printf (_(" Reserved entries:\n"));
15496       printf (_("  %*s %10s %*s Purpose\n"),
15497               addr_size * 2, _("Address"), _("Access"),
15498               addr_size * 2, _("Initial"));
15499       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15500       printf (_(" Lazy resolver\n"));
15501       if (ent == (bfd_vma) -1)
15502         goto got_print_fail;
15503
15504       if (data)
15505         {
15506           /* PR 21344 */
15507           if (data + ent - pltgot > data_end - addr_size)
15508             {
15509               error (_("Invalid got entry - %#lx - overflows GOT table\n"),
15510                      (long) ent);
15511               goto got_print_fail;
15512             }
15513
15514           if (byte_get (data + ent - pltgot, addr_size)
15515               >> (addr_size * 8 - 1) != 0)
15516             {
15517               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15518               printf (_(" Module pointer (GNU extension)\n"));
15519               if (ent == (bfd_vma) -1)
15520                 goto got_print_fail;
15521             }
15522         }
15523       printf ("\n");
15524
15525       if (ent < local_end)
15526         {
15527           printf (_(" Local entries:\n"));
15528           printf ("  %*s %10s %*s\n",
15529                   addr_size * 2, _("Address"), _("Access"),
15530                   addr_size * 2, _("Initial"));
15531           while (ent < local_end)
15532             {
15533               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15534               printf ("\n");
15535               if (ent == (bfd_vma) -1)
15536                 goto got_print_fail;
15537             }
15538           printf ("\n");
15539         }
15540
15541       if (gotsym < symtabno)
15542         {
15543           int sym_width;
15544
15545           printf (_(" Global entries:\n"));
15546           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15547                   addr_size * 2, _("Address"),
15548                   _("Access"),
15549                   addr_size * 2, _("Initial"),
15550                   addr_size * 2, _("Sym.Val."),
15551                   _("Type"),
15552                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15553                   _("Ndx"), _("Name"));
15554
15555           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15556
15557           for (i = gotsym; i < symtabno; i++)
15558             {
15559               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15560               printf (" ");
15561
15562               if (dynamic_symbols == NULL)
15563                 printf (_("<no dynamic symbols>"));
15564               else if (i < num_dynamic_syms)
15565                 {
15566                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15567
15568                   print_vma (psym->st_value, LONG_HEX);
15569                   printf (" %-7s %3s ",
15570                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15571                           get_symbol_index_type (psym->st_shndx));
15572
15573                   if (VALID_DYNAMIC_NAME (psym->st_name))
15574                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15575                   else
15576                     printf (_("<corrupt: %14ld>"), psym->st_name);
15577                 }
15578               else
15579                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15580                         (unsigned long) i);
15581
15582               printf ("\n");
15583               if (ent == (bfd_vma) -1)
15584                 break;
15585             }
15586           printf ("\n");
15587         }
15588
15589     got_print_fail:
15590       if (data)
15591         free (data);
15592     }
15593
15594   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15595     {
15596       bfd_vma ent, end;
15597       size_t offset, rel_offset;
15598       unsigned long count, i;
15599       unsigned char * data;
15600       int addr_size, sym_width;
15601       Elf_Internal_Rela * rels;
15602
15603       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15604       if (pltrel == DT_RELA)
15605         {
15606           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15607             return FALSE;
15608         }
15609       else
15610         {
15611           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15612             return FALSE;
15613         }
15614
15615       ent = mips_pltgot;
15616       addr_size = (is_32bit_elf ? 4 : 8);
15617       end = mips_pltgot + (2 + count) * addr_size;
15618
15619       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15620       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15621                                          1, _("Procedure Linkage Table data"));
15622       if (data == NULL)
15623         return FALSE;
15624
15625       printf ("\nPLT GOT:\n\n");
15626       printf (_(" Reserved entries:\n"));
15627       printf (_("  %*s %*s Purpose\n"),
15628               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15629       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15630       printf (_(" PLT lazy resolver\n"));
15631       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15632       printf (_(" Module pointer\n"));
15633       printf ("\n");
15634
15635       printf (_(" Entries:\n"));
15636       printf ("  %*s %*s %*s %-7s %3s %s\n",
15637               addr_size * 2, _("Address"),
15638               addr_size * 2, _("Initial"),
15639               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15640       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15641       for (i = 0; i < count; i++)
15642         {
15643           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15644
15645           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15646           printf (" ");
15647
15648           if (idx >= num_dynamic_syms)
15649             printf (_("<corrupt symbol index: %lu>"), idx);
15650           else
15651             {
15652               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15653
15654               print_vma (psym->st_value, LONG_HEX);
15655               printf (" %-7s %3s ",
15656                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15657                       get_symbol_index_type (psym->st_shndx));
15658               if (VALID_DYNAMIC_NAME (psym->st_name))
15659                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15660               else
15661                 printf (_("<corrupt: %14ld>"), psym->st_name);
15662             }
15663           printf ("\n");
15664         }
15665       printf ("\n");
15666
15667       if (data)
15668         free (data);
15669       free (rels);
15670     }
15671
15672   return res;
15673 }
15674
15675 static bfd_boolean
15676 process_nds32_specific (FILE * file)
15677 {
15678   Elf_Internal_Shdr *sect = NULL;
15679
15680   sect = find_section (".nds32_e_flags");
15681   if (sect != NULL)
15682     {
15683       unsigned int *flag;
15684
15685       printf ("\nNDS32 elf flags section:\n");
15686       flag = get_data (NULL, file, sect->sh_offset, 1,
15687                        sect->sh_size, _("NDS32 elf flags section"));
15688
15689       if (! flag)
15690         return FALSE;
15691
15692       switch ((*flag) & 0x3)
15693         {
15694         case 0:
15695           printf ("(VEC_SIZE):\tNo entry.\n");
15696           break;
15697         case 1:
15698           printf ("(VEC_SIZE):\t4 bytes\n");
15699           break;
15700         case 2:
15701           printf ("(VEC_SIZE):\t16 bytes\n");
15702           break;
15703         case 3:
15704           printf ("(VEC_SIZE):\treserved\n");
15705           break;
15706         }
15707     }
15708
15709   return TRUE;
15710 }
15711
15712 static bfd_boolean
15713 process_gnu_liblist (FILE * file)
15714 {
15715   Elf_Internal_Shdr * section;
15716   Elf_Internal_Shdr * string_sec;
15717   Elf32_External_Lib * elib;
15718   char * strtab;
15719   size_t strtab_size;
15720   size_t cnt;
15721   unsigned i;
15722   bfd_boolean res = TRUE;
15723
15724   if (! do_arch)
15725     return TRUE;
15726
15727   for (i = 0, section = section_headers;
15728        i < elf_header.e_shnum;
15729        i++, section++)
15730     {
15731       switch (section->sh_type)
15732         {
15733         case SHT_GNU_LIBLIST:
15734           if (section->sh_link >= elf_header.e_shnum)
15735             break;
15736
15737           elib = (Elf32_External_Lib *)
15738               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
15739                         _("liblist section data"));
15740
15741           if (elib == NULL)
15742             {
15743               res = FALSE;
15744               break;
15745             }
15746
15747           string_sec = section_headers + section->sh_link;
15748           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15749                                       string_sec->sh_size,
15750                                       _("liblist string table"));
15751           if (strtab == NULL
15752               || section->sh_entsize != sizeof (Elf32_External_Lib))
15753             {
15754               free (elib);
15755               free (strtab);
15756               res = FALSE;
15757               break;
15758             }
15759           strtab_size = string_sec->sh_size;
15760
15761           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15762                   printable_section_name (section),
15763                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
15764
15765           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
15766
15767           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15768                ++cnt)
15769             {
15770               Elf32_Lib liblist;
15771               time_t atime;
15772               char timebuf[128];
15773               struct tm * tmp;
15774
15775               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15776               atime = BYTE_GET (elib[cnt].l_time_stamp);
15777               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15778               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15779               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15780
15781               tmp = gmtime (&atime);
15782               snprintf (timebuf, sizeof (timebuf),
15783                         "%04u-%02u-%02uT%02u:%02u:%02u",
15784                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15785                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15786
15787               printf ("%3lu: ", (unsigned long) cnt);
15788               if (do_wide)
15789                 printf ("%-20s", liblist.l_name < strtab_size
15790                         ? strtab + liblist.l_name : _("<corrupt>"));
15791               else
15792                 printf ("%-20.20s", liblist.l_name < strtab_size
15793                         ? strtab + liblist.l_name : _("<corrupt>"));
15794               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15795                       liblist.l_version, liblist.l_flags);
15796             }
15797
15798           free (elib);
15799           free (strtab);
15800         }
15801     }
15802
15803   return res;
15804 }
15805
15806 static const char *
15807 get_note_type (unsigned e_type)
15808 {
15809   static char buff[64];
15810
15811   if (elf_header.e_type == ET_CORE)
15812     switch (e_type)
15813       {
15814       case NT_AUXV:
15815         return _("NT_AUXV (auxiliary vector)");
15816       case NT_PRSTATUS:
15817         return _("NT_PRSTATUS (prstatus structure)");
15818       case NT_FPREGSET:
15819         return _("NT_FPREGSET (floating point registers)");
15820       case NT_PRPSINFO:
15821         return _("NT_PRPSINFO (prpsinfo structure)");
15822       case NT_TASKSTRUCT:
15823         return _("NT_TASKSTRUCT (task structure)");
15824       case NT_PRXFPREG:
15825         return _("NT_PRXFPREG (user_xfpregs structure)");
15826       case NT_PPC_VMX:
15827         return _("NT_PPC_VMX (ppc Altivec registers)");
15828       case NT_PPC_VSX:
15829         return _("NT_PPC_VSX (ppc VSX registers)");
15830       case NT_386_TLS:
15831         return _("NT_386_TLS (x86 TLS information)");
15832       case NT_386_IOPERM:
15833         return _("NT_386_IOPERM (x86 I/O permissions)");
15834       case NT_X86_XSTATE:
15835         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15836       case NT_S390_HIGH_GPRS:
15837         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15838       case NT_S390_TIMER:
15839         return _("NT_S390_TIMER (s390 timer register)");
15840       case NT_S390_TODCMP:
15841         return _("NT_S390_TODCMP (s390 TOD comparator register)");
15842       case NT_S390_TODPREG:
15843         return _("NT_S390_TODPREG (s390 TOD programmable register)");
15844       case NT_S390_CTRS:
15845         return _("NT_S390_CTRS (s390 control registers)");
15846       case NT_S390_PREFIX:
15847         return _("NT_S390_PREFIX (s390 prefix register)");
15848       case NT_S390_LAST_BREAK:
15849         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15850       case NT_S390_SYSTEM_CALL:
15851         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15852       case NT_S390_TDB:
15853         return _("NT_S390_TDB (s390 transaction diagnostic block)");
15854       case NT_S390_VXRS_LOW:
15855         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15856       case NT_S390_VXRS_HIGH:
15857         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15858       case NT_ARM_VFP:
15859         return _("NT_ARM_VFP (arm VFP registers)");
15860       case NT_ARM_TLS:
15861         return _("NT_ARM_TLS (AArch TLS registers)");
15862       case NT_ARM_HW_BREAK:
15863         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15864       case NT_ARM_HW_WATCH:
15865         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15866       case NT_PSTATUS:
15867         return _("NT_PSTATUS (pstatus structure)");
15868       case NT_FPREGS:
15869         return _("NT_FPREGS (floating point registers)");
15870       case NT_PSINFO:
15871         return _("NT_PSINFO (psinfo structure)");
15872       case NT_LWPSTATUS:
15873         return _("NT_LWPSTATUS (lwpstatus_t structure)");
15874       case NT_LWPSINFO:
15875         return _("NT_LWPSINFO (lwpsinfo_t structure)");
15876       case NT_WIN32PSTATUS:
15877         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15878       case NT_SIGINFO:
15879         return _("NT_SIGINFO (siginfo_t data)");
15880       case NT_FILE:
15881         return _("NT_FILE (mapped files)");
15882       default:
15883         break;
15884       }
15885   else
15886     switch (e_type)
15887       {
15888       case NT_VERSION:
15889         return _("NT_VERSION (version)");
15890       case NT_ARCH:
15891         return _("NT_ARCH (architecture)");
15892       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15893         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15894       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15895         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15896       default:
15897         break;
15898       }
15899
15900   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15901   return buff;
15902 }
15903
15904 static bfd_boolean
15905 print_core_note (Elf_Internal_Note *pnote)
15906 {
15907   unsigned int addr_size = is_32bit_elf ? 4 : 8;
15908   bfd_vma count, page_size;
15909   unsigned char *descdata, *filenames, *descend;
15910
15911   if (pnote->type != NT_FILE)
15912     return TRUE;
15913
15914 #ifndef BFD64
15915   if (!is_32bit_elf)
15916     {
15917       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
15918       /* Still "successful".  */
15919       return TRUE;
15920     }
15921 #endif
15922
15923   if (pnote->descsz < 2 * addr_size)
15924     {
15925       error (_("    Malformed note - too short for header\n"));
15926       return FALSE;
15927     }
15928
15929   descdata = (unsigned char *) pnote->descdata;
15930   descend = descdata + pnote->descsz;
15931
15932   if (descdata[pnote->descsz - 1] != '\0')
15933     {
15934       error (_("    Malformed note - does not end with \\0\n"));
15935       return FALSE;
15936     }
15937
15938   count = byte_get (descdata, addr_size);
15939   descdata += addr_size;
15940
15941   page_size = byte_get (descdata, addr_size);
15942   descdata += addr_size;
15943
15944   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15945     {
15946       error (_("    Malformed note - too short for supplied file count\n"));
15947       return FALSE;
15948     }
15949
15950   printf (_("    Page size: "));
15951   print_vma (page_size, DEC);
15952   printf ("\n");
15953
15954   printf (_("    %*s%*s%*s\n"),
15955           (int) (2 + 2 * addr_size), _("Start"),
15956           (int) (4 + 2 * addr_size), _("End"),
15957           (int) (4 + 2 * addr_size), _("Page Offset"));
15958   filenames = descdata + count * 3 * addr_size;
15959   while (count-- > 0)
15960     {
15961       bfd_vma start, end, file_ofs;
15962
15963       if (filenames == descend)
15964         {
15965           error (_("    Malformed note - filenames end too early\n"));
15966           return FALSE;
15967         }
15968
15969       start = byte_get (descdata, addr_size);
15970       descdata += addr_size;
15971       end = byte_get (descdata, addr_size);
15972       descdata += addr_size;
15973       file_ofs = byte_get (descdata, addr_size);
15974       descdata += addr_size;
15975
15976       printf ("    ");
15977       print_vma (start, FULL_HEX);
15978       printf ("  ");
15979       print_vma (end, FULL_HEX);
15980       printf ("  ");
15981       print_vma (file_ofs, FULL_HEX);
15982       printf ("\n        %s\n", filenames);
15983
15984       filenames += 1 + strlen ((char *) filenames);
15985     }
15986
15987   return TRUE;
15988 }
15989
15990 static const char *
15991 get_gnu_elf_note_type (unsigned e_type)
15992 {
15993   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
15994   switch (e_type)
15995     {
15996     case NT_GNU_ABI_TAG:
15997       return _("NT_GNU_ABI_TAG (ABI version tag)");
15998     case NT_GNU_HWCAP:
15999       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16000     case NT_GNU_BUILD_ID:
16001       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16002     case NT_GNU_GOLD_VERSION:
16003       return _("NT_GNU_GOLD_VERSION (gold version)");
16004     case NT_GNU_PROPERTY_TYPE_0:
16005       return _("NT_GNU_PROPERTY_TYPE_0");
16006     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16007       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16008     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16009       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16010     default:
16011       {
16012         static char buff[64];
16013
16014         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16015         return buff;
16016       }
16017     }
16018 }
16019
16020 static void
16021 decode_x86_isa (unsigned int bitmask)
16022 {
16023   while (bitmask)
16024     {
16025       unsigned int bit = bitmask & (- bitmask);
16026
16027       bitmask &= ~ bit;
16028       switch (bit)
16029         {
16030         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16031         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16032         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16033         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16034         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16035         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16036         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16037         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16038         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16039         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16040         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16041         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16042         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16043         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16044         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16045         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16046         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16047         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16048         default: printf (_("<unknown: %x>"), bit); break;
16049         }
16050       if (bitmask)
16051         printf (", ");
16052     }
16053 }
16054
16055 static void
16056 print_gnu_property_note (Elf_Internal_Note * pnote)
16057 {
16058   unsigned char * ptr = (unsigned char *) pnote->descdata;
16059   unsigned char * ptr_end = ptr + pnote->descsz;
16060   unsigned int    size = is_32bit_elf ? 4 : 8;
16061
16062   printf (_("      Properties: "));
16063
16064   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16065     {
16066       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16067       return;
16068     }
16069
16070   while (1)
16071     {
16072       unsigned int j;
16073       unsigned int type = byte_get (ptr, 4);
16074       unsigned int datasz = byte_get (ptr + 4, 4);
16075
16076       ptr += 8;
16077
16078       if ((ptr + datasz) > ptr_end)
16079         {
16080           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16081                   type, datasz);
16082           break;
16083         }
16084
16085       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16086         {
16087           if (elf_header.e_machine == EM_X86_64
16088               || elf_header.e_machine == EM_IAMCU
16089               || elf_header.e_machine == EM_386)
16090             {
16091               switch (type)
16092                 {
16093                 case GNU_PROPERTY_X86_ISA_1_USED:
16094                   printf ("x86 ISA used: ");
16095                   if (datasz != 4)
16096                     printf (_("<corrupt length: %#x> "), datasz);
16097                   else
16098                     decode_x86_isa (byte_get (ptr, 4));
16099                   goto next;
16100
16101                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16102                   printf ("x86 ISA needed: ");
16103                   if (datasz != 4)
16104                     printf (_("<corrupt length: %#x> "), datasz);
16105                   else
16106                     decode_x86_isa (byte_get (ptr, 4));
16107                   goto next;
16108
16109                 default:
16110                   break;
16111                 }
16112             }
16113         }
16114       else
16115         {
16116           switch (type)
16117             {
16118             case GNU_PROPERTY_STACK_SIZE:
16119               printf (_("stack size: "));
16120               if (datasz != size)
16121                 printf (_("<corrupt length: %#x> "), datasz);
16122               else
16123                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16124               goto next;
16125
16126             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16127               printf ("no copy on protected ");
16128               if (datasz)
16129                 printf (_("<corrupt length: %#x> "), datasz);
16130               goto next;
16131
16132             default:
16133               break;
16134             }
16135         }
16136
16137       if (type < GNU_PROPERTY_LOPROC)
16138         printf (_("<unknown type %#x data: "), type);
16139       else if (type < GNU_PROPERTY_LOUSER)
16140         printf (_("<procesor-specific type %#x data: "), type);
16141       else
16142         printf (_("<application-specific type %#x data: "), type);
16143       for (j = 0; j < datasz; ++j)
16144         printf ("%02x ", ptr[j] & 0xff);
16145       printf (">");
16146
16147 next:
16148       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16149       if (ptr == ptr_end)
16150         break;
16151       else
16152         {
16153           if (do_wide)
16154             printf (", ");
16155           else
16156             printf ("\n\t");
16157         }
16158
16159       if (ptr > (ptr_end - 8))
16160         {
16161           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16162           break;
16163         }
16164     }
16165
16166   printf ("\n");
16167 }
16168
16169 static bfd_boolean
16170 print_gnu_note (Elf_Internal_Note *pnote)
16171 {
16172   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16173   switch (pnote->type)
16174     {
16175     case NT_GNU_BUILD_ID:
16176       {
16177         unsigned long i;
16178
16179         printf (_("    Build ID: "));
16180         for (i = 0; i < pnote->descsz; ++i)
16181           printf ("%02x", pnote->descdata[i] & 0xff);
16182         printf ("\n");
16183       }
16184       break;
16185
16186     case NT_GNU_ABI_TAG:
16187       {
16188         unsigned long os, major, minor, subminor;
16189         const char *osname;
16190
16191         /* PR 17531: file: 030-599401-0.004.  */
16192         if (pnote->descsz < 16)
16193           {
16194             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16195             break;
16196           }
16197
16198         os = byte_get ((unsigned char *) pnote->descdata, 4);
16199         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16200         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16201         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16202
16203         switch (os)
16204           {
16205           case GNU_ABI_TAG_LINUX:
16206             osname = "Linux";
16207             break;
16208           case GNU_ABI_TAG_HURD:
16209             osname = "Hurd";
16210             break;
16211           case GNU_ABI_TAG_SOLARIS:
16212             osname = "Solaris";
16213             break;
16214           case GNU_ABI_TAG_FREEBSD:
16215             osname = "FreeBSD";
16216             break;
16217           case GNU_ABI_TAG_NETBSD:
16218             osname = "NetBSD";
16219             break;
16220           case GNU_ABI_TAG_SYLLABLE:
16221             osname = "Syllable";
16222             break;
16223           case GNU_ABI_TAG_NACL:
16224             osname = "NaCl";
16225             break;
16226           default:
16227             osname = "Unknown";
16228             break;
16229           }
16230
16231         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16232                 major, minor, subminor);
16233       }
16234       break;
16235
16236     case NT_GNU_GOLD_VERSION:
16237       {
16238         unsigned long i;
16239
16240         printf (_("    Version: "));
16241         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16242           printf ("%c", pnote->descdata[i]);
16243         printf ("\n");
16244       }
16245       break;
16246
16247     case NT_GNU_HWCAP:
16248       {
16249         unsigned long num_entries, mask;
16250
16251         /* Hardware capabilities information.  Word 0 is the number of entries.
16252            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16253            is a series of entries, where each entry is a single byte followed
16254            by a nul terminated string.  The byte gives the bit number to test
16255            if enabled in the bitmask.  */
16256         printf (_("      Hardware Capabilities: "));
16257         if (pnote->descsz < 8)
16258           {
16259             error (_("<corrupt GNU_HWCAP>\n"));
16260             return FALSE;
16261           }
16262         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16263         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16264         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16265         /* FIXME: Add code to display the entries... */
16266       }
16267       break;
16268
16269     case NT_GNU_PROPERTY_TYPE_0:
16270       print_gnu_property_note (pnote);
16271       break;
16272
16273     default:
16274       /* Handle unrecognised types.  An error message should have already been
16275          created by get_gnu_elf_note_type(), so all that we need to do is to
16276          display the data.  */
16277       {
16278         unsigned long i;
16279
16280         printf (_("    Description data: "));
16281         for (i = 0; i < pnote->descsz; ++i)
16282           printf ("%02x ", pnote->descdata[i] & 0xff);
16283         printf ("\n");
16284       }
16285       break;
16286     }
16287
16288   return TRUE;
16289 }
16290
16291 static const char *
16292 get_v850_elf_note_type (enum v850_notes n_type)
16293 {
16294   static char buff[64];
16295
16296   switch (n_type)
16297     {
16298     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16299     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16300     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16301     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16302     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16303     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16304     default:
16305       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16306       return buff;
16307     }
16308 }
16309
16310 static bfd_boolean
16311 print_v850_note (Elf_Internal_Note * pnote)
16312 {
16313   unsigned int val;
16314
16315   if (pnote->descsz != 4)
16316     return FALSE;
16317
16318   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16319
16320   if (val == 0)
16321     {
16322       printf (_("not set\n"));
16323       return TRUE;
16324     }
16325
16326   switch (pnote->type)
16327     {
16328     case V850_NOTE_ALIGNMENT:
16329       switch (val)
16330         {
16331         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16332         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16333         }
16334       break;
16335
16336     case V850_NOTE_DATA_SIZE:
16337       switch (val)
16338         {
16339         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16340         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16341         }
16342       break;
16343
16344     case V850_NOTE_FPU_INFO:
16345       switch (val)
16346         {
16347         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16348         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16349         }
16350       break;
16351
16352     case V850_NOTE_MMU_INFO:
16353     case V850_NOTE_CACHE_INFO:
16354     case V850_NOTE_SIMD_INFO:
16355       if (val == EF_RH850_SIMD)
16356         {
16357           printf (_("yes\n"));
16358           return TRUE;
16359         }
16360       break;
16361
16362     default:
16363       /* An 'unknown note type' message will already have been displayed.  */
16364       break;
16365     }
16366
16367   printf (_("unknown value: %x\n"), val);
16368   return FALSE;
16369 }
16370
16371 static bfd_boolean
16372 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16373 {
16374   unsigned int version;
16375
16376   switch (pnote->type)
16377     {
16378     case NT_NETBSD_IDENT:
16379       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16380       if ((version / 10000) % 100)
16381         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16382                 version, version / 100000000, (version / 1000000) % 100,
16383                 (version / 10000) % 100 > 26 ? "Z" : "",
16384                 'A' + (version / 10000) % 26);
16385       else
16386         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16387                 version, version / 100000000, (version / 1000000) % 100,
16388                 (version / 100) % 100);
16389       return TRUE;
16390
16391     case NT_NETBSD_MARCH:
16392       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16393               pnote->descdata);
16394       return TRUE;
16395
16396     default:
16397       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16398               pnote->type);
16399       return FALSE;
16400     }
16401 }
16402
16403 static const char *
16404 get_freebsd_elfcore_note_type (unsigned e_type)
16405 {
16406   switch (e_type)
16407     {
16408     case NT_FREEBSD_THRMISC:
16409       return _("NT_THRMISC (thrmisc structure)");
16410     case NT_FREEBSD_PROCSTAT_PROC:
16411       return _("NT_PROCSTAT_PROC (proc data)");
16412     case NT_FREEBSD_PROCSTAT_FILES:
16413       return _("NT_PROCSTAT_FILES (files data)");
16414     case NT_FREEBSD_PROCSTAT_VMMAP:
16415       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16416     case NT_FREEBSD_PROCSTAT_GROUPS:
16417       return _("NT_PROCSTAT_GROUPS (groups data)");
16418     case NT_FREEBSD_PROCSTAT_UMASK:
16419       return _("NT_PROCSTAT_UMASK (umask data)");
16420     case NT_FREEBSD_PROCSTAT_RLIMIT:
16421       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16422     case NT_FREEBSD_PROCSTAT_OSREL:
16423       return _("NT_PROCSTAT_OSREL (osreldate data)");
16424     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16425       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16426     case NT_FREEBSD_PROCSTAT_AUXV:
16427       return _("NT_PROCSTAT_AUXV (auxv data)");
16428     }
16429   return get_note_type (e_type);
16430 }
16431
16432 static const char *
16433 get_netbsd_elfcore_note_type (unsigned e_type)
16434 {
16435   static char buff[64];
16436
16437   if (e_type == NT_NETBSDCORE_PROCINFO)
16438     {
16439       /* NetBSD core "procinfo" structure.  */
16440       return _("NetBSD procinfo structure");
16441     }
16442
16443   /* As of Jan 2002 there are no other machine-independent notes
16444      defined for NetBSD core files.  If the note type is less
16445      than the start of the machine-dependent note types, we don't
16446      understand it.  */
16447
16448   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16449     {
16450       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16451       return buff;
16452     }
16453
16454   switch (elf_header.e_machine)
16455     {
16456     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16457        and PT_GETFPREGS == mach+2.  */
16458
16459     case EM_OLD_ALPHA:
16460     case EM_ALPHA:
16461     case EM_SPARC:
16462     case EM_SPARC32PLUS:
16463     case EM_SPARCV9:
16464       switch (e_type)
16465         {
16466         case NT_NETBSDCORE_FIRSTMACH + 0:
16467           return _("PT_GETREGS (reg structure)");
16468         case NT_NETBSDCORE_FIRSTMACH + 2:
16469           return _("PT_GETFPREGS (fpreg structure)");
16470         default:
16471           break;
16472         }
16473       break;
16474
16475     /* On all other arch's, PT_GETREGS == mach+1 and
16476        PT_GETFPREGS == mach+3.  */
16477     default:
16478       switch (e_type)
16479         {
16480         case NT_NETBSDCORE_FIRSTMACH + 1:
16481           return _("PT_GETREGS (reg structure)");
16482         case NT_NETBSDCORE_FIRSTMACH + 3:
16483           return _("PT_GETFPREGS (fpreg structure)");
16484         default:
16485           break;
16486         }
16487     }
16488
16489   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16490             e_type - NT_NETBSDCORE_FIRSTMACH);
16491   return buff;
16492 }
16493
16494 static const char *
16495 get_stapsdt_note_type (unsigned e_type)
16496 {
16497   static char buff[64];
16498
16499   switch (e_type)
16500     {
16501     case NT_STAPSDT:
16502       return _("NT_STAPSDT (SystemTap probe descriptors)");
16503
16504     default:
16505       break;
16506     }
16507
16508   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16509   return buff;
16510 }
16511
16512 static bfd_boolean
16513 print_stapsdt_note (Elf_Internal_Note *pnote)
16514 {
16515   int addr_size = is_32bit_elf ? 4 : 8;
16516   char *data = pnote->descdata;
16517   char *data_end = pnote->descdata + pnote->descsz;
16518   bfd_vma pc, base_addr, semaphore;
16519   char *provider, *probe, *arg_fmt;
16520
16521   pc = byte_get ((unsigned char *) data, addr_size);
16522   data += addr_size;
16523   base_addr = byte_get ((unsigned char *) data, addr_size);
16524   data += addr_size;
16525   semaphore = byte_get ((unsigned char *) data, addr_size);
16526   data += addr_size;
16527
16528   provider = data;
16529   data += strlen (data) + 1;
16530   probe = data;
16531   data += strlen (data) + 1;
16532   arg_fmt = data;
16533   data += strlen (data) + 1;
16534
16535   printf (_("    Provider: %s\n"), provider);
16536   printf (_("    Name: %s\n"), probe);
16537   printf (_("    Location: "));
16538   print_vma (pc, FULL_HEX);
16539   printf (_(", Base: "));
16540   print_vma (base_addr, FULL_HEX);
16541   printf (_(", Semaphore: "));
16542   print_vma (semaphore, FULL_HEX);
16543   printf ("\n");
16544   printf (_("    Arguments: %s\n"), arg_fmt);
16545
16546   return data == data_end;
16547 }
16548
16549 static const char *
16550 get_ia64_vms_note_type (unsigned e_type)
16551 {
16552   static char buff[64];
16553
16554   switch (e_type)
16555     {
16556     case NT_VMS_MHD:
16557       return _("NT_VMS_MHD (module header)");
16558     case NT_VMS_LNM:
16559       return _("NT_VMS_LNM (language name)");
16560     case NT_VMS_SRC:
16561       return _("NT_VMS_SRC (source files)");
16562     case NT_VMS_TITLE:
16563       return "NT_VMS_TITLE";
16564     case NT_VMS_EIDC:
16565       return _("NT_VMS_EIDC (consistency check)");
16566     case NT_VMS_FPMODE:
16567       return _("NT_VMS_FPMODE (FP mode)");
16568     case NT_VMS_LINKTIME:
16569       return "NT_VMS_LINKTIME";
16570     case NT_VMS_IMGNAM:
16571       return _("NT_VMS_IMGNAM (image name)");
16572     case NT_VMS_IMGID:
16573       return _("NT_VMS_IMGID (image id)");
16574     case NT_VMS_LINKID:
16575       return _("NT_VMS_LINKID (link id)");
16576     case NT_VMS_IMGBID:
16577       return _("NT_VMS_IMGBID (build id)");
16578     case NT_VMS_GSTNAM:
16579       return _("NT_VMS_GSTNAM (sym table name)");
16580     case NT_VMS_ORIG_DYN:
16581       return "NT_VMS_ORIG_DYN";
16582     case NT_VMS_PATCHTIME:
16583       return "NT_VMS_PATCHTIME";
16584     default:
16585       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16586       return buff;
16587     }
16588 }
16589
16590 static bfd_boolean
16591 print_ia64_vms_note (Elf_Internal_Note * pnote)
16592 {
16593   switch (pnote->type)
16594     {
16595     case NT_VMS_MHD:
16596       if (pnote->descsz > 36)
16597         {
16598           size_t l = strlen (pnote->descdata + 34);
16599           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
16600           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
16601           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
16602           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
16603         }
16604       else
16605         printf (_("    Invalid size\n"));
16606       break;
16607     case NT_VMS_LNM:
16608       printf (_("   Language: %s\n"), pnote->descdata);
16609       break;
16610 #ifdef BFD64
16611     case NT_VMS_FPMODE:
16612       printf (_("   Floating Point mode: "));
16613       printf ("0x%016" BFD_VMA_FMT "x\n",
16614               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
16615       break;
16616     case NT_VMS_LINKTIME:
16617       printf (_("   Link time: "));
16618       print_vms_time
16619         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16620       printf ("\n");
16621       break;
16622     case NT_VMS_PATCHTIME:
16623       printf (_("   Patch time: "));
16624       print_vms_time
16625         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16626       printf ("\n");
16627       break;
16628     case NT_VMS_ORIG_DYN:
16629       printf (_("   Major id: %u,  minor id: %u\n"),
16630               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16631               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
16632       printf (_("   Last modified  : "));
16633       print_vms_time
16634         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
16635       printf (_("\n   Link flags  : "));
16636       printf ("0x%016" BFD_VMA_FMT "x\n",
16637               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
16638       printf (_("   Header flags: 0x%08x\n"),
16639               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
16640       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
16641       break;
16642 #endif
16643     case NT_VMS_IMGNAM:
16644       printf (_("    Image name: %s\n"), pnote->descdata);
16645       break;
16646     case NT_VMS_GSTNAM:
16647       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
16648       break;
16649     case NT_VMS_IMGID:
16650       printf (_("    Image id: %s\n"), pnote->descdata);
16651       break;
16652     case NT_VMS_LINKID:
16653       printf (_("    Linker id: %s\n"), pnote->descdata);
16654       break;
16655     default:
16656       return FALSE;
16657     }
16658   return TRUE;
16659 }
16660
16661 /* Print the name of the symbol associated with a build attribute
16662    that is attached to address OFFSET.  */
16663
16664 static bfd_boolean
16665 print_symbol_for_build_attribute (FILE *         file,
16666                                   unsigned long  offset,
16667                                   bfd_boolean    is_open_attr)
16668 {
16669   static FILE *             saved_file = NULL;
16670   static char *             strtab;
16671   static unsigned long      strtablen;
16672   static Elf_Internal_Sym * symtab;
16673   static unsigned long      nsyms;
16674   Elf_Internal_Sym *        saved_sym = NULL;
16675   Elf_Internal_Sym *        sym;
16676
16677   if (section_headers != NULL
16678       && (saved_file == NULL || file != saved_file))
16679     {
16680       Elf_Internal_Shdr * symsec;
16681
16682       /* Load the symbol and string sections.  */
16683       for (symsec = section_headers;
16684            symsec < section_headers + elf_header.e_shnum;
16685            symsec ++)
16686         {
16687           if (symsec->sh_type == SHT_SYMTAB)
16688             {
16689               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
16690
16691               if (symsec->sh_link < elf_header.e_shnum)
16692                 {
16693                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
16694
16695                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
16696                                               1, strtab_sec->sh_size,
16697                                               _("string table"));
16698                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
16699                 }
16700             }
16701         }
16702       saved_file = file;
16703     }
16704
16705   if (symtab == NULL || strtab == NULL)
16706     {
16707       printf ("\n");
16708       return FALSE;
16709     }
16710
16711   /* Find a symbol whose value matches offset.  */
16712   for (sym = symtab; sym < symtab + nsyms; sym ++)
16713     if (sym->st_value == offset)
16714       {
16715         if (sym->st_name >= strtablen)
16716           /* Huh ?  This should not happen.  */
16717           continue;
16718
16719         if (strtab[sym->st_name] == 0)
16720           continue;
16721
16722         if (is_open_attr)
16723           {
16724             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16725                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
16726                FUNC symbols entirely.  */
16727             switch (ELF_ST_TYPE (sym->st_info))
16728               {
16729               case STT_FILE:
16730                 saved_sym = sym;
16731                 /* We can stop searching now.  */
16732                 sym = symtab + nsyms;
16733                 continue;
16734
16735               case STT_OBJECT:
16736                 saved_sym = sym;
16737                 continue;
16738
16739               case STT_FUNC:
16740                 /* Ignore function symbols.  */
16741                 continue;
16742
16743               default:
16744                 break;
16745               }
16746
16747             switch (ELF_ST_BIND (sym->st_info))
16748               {
16749               case STB_GLOBAL:
16750                 if (saved_sym == NULL
16751                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
16752                   saved_sym = sym;
16753                 break;
16754
16755               case STB_LOCAL:
16756                 if (saved_sym == NULL)
16757                   saved_sym = sym;
16758                 break;
16759
16760               default:
16761                 break;
16762               }
16763           }
16764         else
16765           {
16766             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
16767               continue;
16768
16769             saved_sym = sym;
16770             break;
16771           }
16772       }
16773
16774   printf (" (%s: %s)\n",
16775           is_open_attr ? _("file") : _("func"),
16776           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
16777   return TRUE;
16778 }
16779
16780 static bfd_boolean
16781 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
16782                                        FILE *              file)
16783 {
16784   static unsigned long global_offset = 0;
16785   unsigned long        offset;
16786   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
16787   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
16788
16789   if (pnote->descsz == 0)
16790     {
16791       if (is_open_attr)
16792         {
16793           printf (_("    Applies from offset %#lx\n"), global_offset);
16794           return TRUE;
16795         }
16796       else
16797         {
16798           printf (_("    Applies to func at %#lx"), global_offset);
16799           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
16800         }
16801     }
16802
16803   if (pnote->descsz != desc_size)
16804     {
16805       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
16806       printf (_("    <invalid descsz>"));
16807       return FALSE;
16808     }
16809
16810   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
16811
16812   if (is_open_attr)
16813     {
16814       printf (_("    Applies from offset %#lx"), offset);
16815       global_offset = offset;
16816     }
16817   else
16818     {
16819       printf (_("    Applies to func at %#lx"), offset);
16820     }
16821
16822   return print_symbol_for_build_attribute (file, offset, is_open_attr);
16823 }
16824
16825 static bfd_boolean
16826 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
16827 {
16828   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
16829   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
16830   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
16831   char         name_type;
16832   char         name_attribute;
16833   const char * expected_types;
16834   const char * name = pnote->namedata;
16835   const char * text;
16836   int          left;
16837
16838   if (name == NULL || pnote->namesz < 2)
16839     {
16840       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
16841       print_symbol (-20, _("  <corrupt name>"));
16842       return FALSE;
16843     }
16844
16845   switch ((name_type = * name))
16846     {
16847     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16848     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16849     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16850     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16851       printf ("%c", * name);
16852       break;
16853     default:
16854       error (_("unrecognised attribute type in name field: %d\n"), name_type);
16855       print_symbol (-20, _("<unknown name type>"));
16856       return FALSE;
16857     }
16858
16859   left = 19;
16860   ++ name;
16861   text = NULL;
16862
16863   switch ((name_attribute = * name))
16864     {
16865     case GNU_BUILD_ATTRIBUTE_VERSION:
16866       text = _("<version>");
16867       expected_types = string_expected;
16868       ++ name;
16869       break;
16870     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16871       text = _("<stack prot>");
16872       expected_types = "!+*";
16873       ++ name;
16874       break;
16875     case GNU_BUILD_ATTRIBUTE_RELRO:
16876       text = _("<relro>");
16877       expected_types = bool_expected;
16878       ++ name;
16879       break;
16880     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
16881       text = _("<stack size>");
16882       expected_types = number_expected;
16883       ++ name;
16884       break;
16885     case GNU_BUILD_ATTRIBUTE_TOOL:
16886       text = _("<tool>");
16887       expected_types = string_expected;
16888       ++ name;
16889       break;
16890     case GNU_BUILD_ATTRIBUTE_ABI:
16891       text = _("<ABI>");
16892       expected_types = "$*";
16893       ++ name;
16894       break;
16895     case GNU_BUILD_ATTRIBUTE_PIC:
16896       text = _("<PIC>");
16897       expected_types = number_expected;
16898       ++ name;
16899       break;
16900     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
16901       text = _("<short enum>");
16902       expected_types = bool_expected;
16903       ++ name;
16904       break;
16905
16906     default:
16907       if (ISPRINT (* name))
16908         {
16909           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
16910
16911           if (len > left && ! do_wide)
16912             len = left;
16913           printf ("%.*s:", len, name);
16914           left -= len;
16915           name += len;
16916         }
16917       else
16918         {
16919           error (_("unexpected character in name field\n"));
16920           print_symbol (- left, _("<unknown attribute>"));
16921           return 0;
16922         }
16923       expected_types = "*$!+";
16924       break;
16925     }
16926
16927   if (text)
16928     {
16929       printf ("%s", text);
16930       left -= strlen (text);
16931     }
16932
16933   if (strchr (expected_types, name_type) == NULL)
16934     warn (_("attribute does not have an expected type (%c)\n"), name_type);
16935
16936   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
16937     {
16938       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16939              (unsigned long) pnote->namesz,
16940              (long) (name - pnote->namedata));
16941       return FALSE;
16942     }
16943
16944   if (left < 1 && ! do_wide)
16945     return TRUE;
16946
16947   switch (name_type)
16948     {
16949     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16950       {
16951         unsigned int   bytes = pnote->namesz - (name - pnote->namedata);
16952         unsigned long  val = 0;
16953         unsigned int   shift = 0;
16954         char *         decoded = NULL;
16955
16956         while (bytes --)
16957           {
16958             unsigned long byte = (* name ++) & 0xff;
16959
16960             val |= byte << shift;
16961             shift += 8;
16962           }
16963
16964         switch (name_attribute)
16965           {
16966           case GNU_BUILD_ATTRIBUTE_PIC:
16967             switch (val)
16968               {
16969               case 0: decoded = "static"; break;
16970               case 1: decoded = "pic"; break;
16971               case 2: decoded = "PIC"; break;
16972               case 3: decoded = "pie"; break;
16973               case 4: decoded = "PIE"; break;
16974               default: break;
16975               }
16976             break;
16977           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16978             switch (val)
16979               {
16980                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
16981               case 0: decoded = "off"; break;
16982               case 1: decoded = "on"; break;
16983               case 2: decoded = "all"; break;
16984               case 3: decoded = "strong"; break;
16985               case 4: decoded = "explicit"; break;
16986               default: break;
16987               }
16988             break;
16989           default:
16990             break;
16991           }
16992
16993         if (decoded != NULL)
16994           print_symbol (-left, decoded);
16995         else
16996           {
16997             if (do_wide)
16998               left -= printf ("0x%lx", val);
16999             else
17000               left -= printf ("0x%-.*lx", left, val);
17001           }
17002       }
17003       break;
17004     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17005       left -= print_symbol (- left, name);
17006       break;
17007     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17008       left -= print_symbol (- left, "true");
17009       break;
17010     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17011       left -= print_symbol (- left, "false");
17012       break;
17013     }
17014
17015   if (do_wide && left > 0)
17016     printf ("%-*s", left, " ");
17017
17018   return TRUE;
17019 }
17020
17021 /* Note that by the ELF standard, the name field is already null byte
17022    terminated, and namesz includes the terminating null byte.
17023    I.E. the value of namesz for the name "FSF" is 4.
17024
17025    If the value of namesz is zero, there is no name present.  */
17026
17027 static bfd_boolean
17028 process_note (Elf_Internal_Note *  pnote,
17029               FILE *               file)
17030 {
17031   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17032   const char * nt;
17033
17034   if (pnote->namesz == 0)
17035     /* If there is no note name, then use the default set of
17036        note type strings.  */
17037     nt = get_note_type (pnote->type);
17038
17039   else if (const_strneq (pnote->namedata, "GNU"))
17040     /* GNU-specific object file notes.  */
17041     nt = get_gnu_elf_note_type (pnote->type);
17042
17043   else if (const_strneq (pnote->namedata, "FreeBSD"))
17044     /* FreeBSD-specific core file notes.  */
17045     nt = get_freebsd_elfcore_note_type (pnote->type);
17046
17047   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17048     /* NetBSD-specific core file notes.  */
17049     nt = get_netbsd_elfcore_note_type (pnote->type);
17050
17051   else if (const_strneq (pnote->namedata, "NetBSD"))
17052     /* NetBSD-specific core file notes.  */
17053     return process_netbsd_elf_note (pnote);
17054
17055   else if (strneq (pnote->namedata, "SPU/", 4))
17056     {
17057       /* SPU-specific core file notes.  */
17058       nt = pnote->namedata + 4;
17059       name = "SPU";
17060     }
17061
17062   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17063     /* VMS/ia64-specific file notes.  */
17064     nt = get_ia64_vms_note_type (pnote->type);
17065
17066   else if (const_strneq (pnote->namedata, "stapsdt"))
17067     nt = get_stapsdt_note_type (pnote->type);
17068
17069   else
17070     /* Don't recognize this note name; just use the default set of
17071        note type strings.  */
17072     nt = get_note_type (pnote->type);
17073
17074   printf ("  ");
17075
17076   if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17077       || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17078     print_gnu_build_attribute_name (pnote);
17079   else
17080     print_symbol (-20, name);
17081
17082   if (do_wide)
17083     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17084   else
17085     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17086
17087   if (const_strneq (pnote->namedata, "IPF/VMS"))
17088     return print_ia64_vms_note (pnote);
17089   else if (const_strneq (pnote->namedata, "GNU"))
17090     return print_gnu_note (pnote);
17091   else if (const_strneq (pnote->namedata, "stapsdt"))
17092     return print_stapsdt_note (pnote);
17093   else if (const_strneq (pnote->namedata, "CORE"))
17094     return print_core_note (pnote);
17095   else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17096            || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
17097     return print_gnu_build_attribute_description (pnote, file);
17098
17099   if (pnote->descsz)
17100     {
17101       unsigned long i;
17102
17103       printf (_("   description data: "));
17104       for (i = 0; i < pnote->descsz; i++)
17105         printf ("%02x ", pnote->descdata[i]);
17106     }
17107
17108   if (do_wide)
17109     printf ("\n");
17110
17111   return TRUE;
17112 }
17113
17114 static bfd_boolean
17115 process_notes_at (FILE *              file,
17116                   Elf_Internal_Shdr * section,
17117                   bfd_vma             offset,
17118                   bfd_vma             length)
17119 {
17120   Elf_External_Note * pnotes;
17121   Elf_External_Note * external;
17122   char * end;
17123   bfd_boolean res = TRUE;
17124
17125   if (length <= 0)
17126     return FALSE;
17127
17128   if (section)
17129     {
17130       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17131       if (pnotes)
17132         {
17133           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17134             return FALSE;
17135         }
17136     }
17137   else
17138     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17139                                              _("notes"));
17140   if (pnotes == NULL)
17141     return FALSE;
17142
17143   external = pnotes;
17144
17145   if (section)
17146     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17147   else
17148     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17149             (unsigned long) offset, (unsigned long) length);
17150
17151   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17152
17153   end = (char *) pnotes + length;
17154   while ((char *) external < end)
17155     {
17156       Elf_Internal_Note inote;
17157       size_t min_notesz;
17158       char *next;
17159       char * temp = NULL;
17160       size_t data_remaining = end - (char *) external;
17161
17162       if (!is_ia64_vms ())
17163         {
17164           /* PR binutils/15191
17165              Make sure that there is enough data to read.  */
17166           min_notesz = offsetof (Elf_External_Note, name);
17167           if (data_remaining < min_notesz)
17168             {
17169               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17170                     (int) data_remaining);
17171               break;
17172             }
17173           inote.type     = BYTE_GET (external->type);
17174           inote.namesz   = BYTE_GET (external->namesz);
17175           inote.namedata = external->name;
17176           inote.descsz   = BYTE_GET (external->descsz);
17177           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17178           /* PR 17531: file: 3443835e.  */
17179           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17180             {
17181               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17182                     inote.namesz, (long)(end - inote.namedata));
17183               inote.descdata = inote.namedata;
17184               inote.namesz   = 0;
17185             }
17186
17187           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17188           next = inote.descdata + align_power (inote.descsz, 2);
17189         }
17190       else
17191         {
17192           Elf64_External_VMS_Note *vms_external;
17193
17194           /* PR binutils/15191
17195              Make sure that there is enough data to read.  */
17196           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17197           if (data_remaining < min_notesz)
17198             {
17199               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17200                     (int) data_remaining);
17201               break;
17202             }
17203
17204           vms_external = (Elf64_External_VMS_Note *) external;
17205           inote.type     = BYTE_GET (vms_external->type);
17206           inote.namesz   = BYTE_GET (vms_external->namesz);
17207           inote.namedata = vms_external->name;
17208           inote.descsz   = BYTE_GET (vms_external->descsz);
17209           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17210           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17211           next = inote.descdata + align_power (inote.descsz, 3);
17212         }
17213
17214       if (inote.descdata < (char *) external + min_notesz
17215           || next < (char *) external + min_notesz
17216           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17217           || inote.namedata + inote.namesz < inote.namedata
17218           || inote.descdata + inote.descsz < inote.descdata
17219           || data_remaining < (size_t)(next - (char *) external))
17220         {
17221           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17222                 (unsigned long) ((char *) external - (char *) pnotes));
17223           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17224                 inote.type, inote.namesz, inote.descsz);
17225           break;
17226         }
17227
17228       external = (Elf_External_Note *) next;
17229
17230       /* Verify that name is null terminated.  It appears that at least
17231          one version of Linux (RedHat 6.0) generates corefiles that don't
17232          comply with the ELF spec by failing to include the null byte in
17233          namesz.  */
17234       if (inote.namedata[inote.namesz - 1] != '\0')
17235         {
17236           temp = (char *) malloc (inote.namesz + 1);
17237           if (temp == NULL)
17238             {
17239               error (_("Out of memory allocating space for inote name\n"));
17240               res = FALSE;
17241               break;
17242             }
17243
17244           memcpy (temp, inote.namedata, inote.namesz);
17245           temp[inote.namesz] = 0;
17246
17247           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17248           inote.namedata = temp;
17249         }
17250
17251       if (! process_note (& inote, file))
17252         res = FALSE;
17253
17254       if (temp != NULL)
17255         {
17256           free (temp);
17257           temp = NULL;
17258         }
17259     }
17260
17261   free (pnotes);
17262
17263   return res;
17264 }
17265
17266 static bfd_boolean
17267 process_corefile_note_segments (FILE * file)
17268 {
17269   Elf_Internal_Phdr * segment;
17270   unsigned int i;
17271   bfd_boolean res = TRUE;
17272
17273   if (! get_program_headers (file))
17274     return TRUE;
17275
17276   for (i = 0, segment = program_headers;
17277        i < elf_header.e_phnum;
17278        i++, segment++)
17279     {
17280       if (segment->p_type == PT_NOTE)
17281         if (! process_notes_at (file, NULL,
17282                                 (bfd_vma) segment->p_offset,
17283                                 (bfd_vma) segment->p_filesz))
17284           res = FALSE;
17285     }
17286
17287   return res;
17288 }
17289
17290 static bfd_boolean
17291 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17292 {
17293   Elf_External_Note * pnotes;
17294   Elf_External_Note * external;
17295   char * end;
17296   bfd_boolean res = TRUE;
17297
17298   if (length <= 0)
17299     return FALSE;
17300
17301   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17302                                            _("v850 notes"));
17303   if (pnotes == NULL)
17304     return FALSE;
17305
17306   external = pnotes;
17307   end = (char*) pnotes + length;
17308
17309   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17310           (unsigned long) offset, (unsigned long) length);
17311
17312   while ((char *) external + sizeof (Elf_External_Note) < end)
17313     {
17314       Elf_External_Note * next;
17315       Elf_Internal_Note inote;
17316
17317       inote.type     = BYTE_GET (external->type);
17318       inote.namesz   = BYTE_GET (external->namesz);
17319       inote.namedata = external->name;
17320       inote.descsz   = BYTE_GET (external->descsz);
17321       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17322       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17323
17324       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17325         {
17326           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17327           inote.descdata = inote.namedata;
17328           inote.namesz   = 0;
17329         }
17330
17331       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17332
17333       if (   ((char *) next > end)
17334           || ((char *) next <  (char *) pnotes))
17335         {
17336           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17337                 (unsigned long) ((char *) external - (char *) pnotes));
17338           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17339                 inote.type, inote.namesz, inote.descsz);
17340           break;
17341         }
17342
17343       external = next;
17344
17345       /* Prevent out-of-bounds indexing.  */
17346       if (   inote.namedata + inote.namesz > end
17347           || inote.namedata + inote.namesz < inote.namedata)
17348         {
17349           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17350                 (unsigned long) ((char *) external - (char *) pnotes));
17351           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17352                 inote.type, inote.namesz, inote.descsz);
17353           break;
17354         }
17355
17356       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17357
17358       if (! print_v850_note (& inote))
17359         {
17360           res = FALSE;
17361           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17362                   inote.namesz, inote.descsz);
17363         }
17364     }
17365
17366   free (pnotes);
17367
17368   return res;
17369 }
17370
17371 static bfd_boolean
17372 process_note_sections (FILE * file)
17373 {
17374   Elf_Internal_Shdr * section;
17375   unsigned long i;
17376   unsigned int n = 0;
17377   bfd_boolean res = TRUE;
17378
17379   for (i = 0, section = section_headers;
17380        i < elf_header.e_shnum && section != NULL;
17381        i++, section++)
17382     {
17383       if (section->sh_type == SHT_NOTE)
17384         {
17385           if (! process_notes_at (file, section,
17386                                   (bfd_vma) section->sh_offset,
17387                                   (bfd_vma) section->sh_size))
17388             res = FALSE;
17389           n++;
17390         }
17391
17392       if ((   elf_header.e_machine == EM_V800
17393            || elf_header.e_machine == EM_V850
17394            || elf_header.e_machine == EM_CYGNUS_V850)
17395           && section->sh_type == SHT_RENESAS_INFO)
17396         {
17397           if (! process_v850_notes (file,
17398                                     (bfd_vma) section->sh_offset,
17399                                     (bfd_vma) section->sh_size))
17400             res = FALSE;
17401           n++;
17402         }
17403     }
17404
17405   if (n == 0)
17406     /* Try processing NOTE segments instead.  */
17407     return process_corefile_note_segments (file);
17408
17409   return res;
17410 }
17411
17412 static bfd_boolean
17413 process_notes (FILE * file)
17414 {
17415   /* If we have not been asked to display the notes then do nothing.  */
17416   if (! do_notes)
17417     return TRUE;
17418
17419   if (elf_header.e_type != ET_CORE)
17420     return process_note_sections (file);
17421
17422   /* No program headers means no NOTE segment.  */
17423   if (elf_header.e_phnum > 0)
17424     return process_corefile_note_segments (file);
17425
17426   printf (_("No note segments present in the core file.\n"));
17427   return TRUE;
17428 }
17429
17430 static unsigned char *
17431 display_public_gnu_attributes (unsigned char * start,
17432                                const unsigned char * const end)
17433 {
17434   printf (_("  Unknown GNU attribute: %s\n"), start);
17435
17436   start += strnlen ((char *) start, end - start);
17437   display_raw_attribute (start, end);
17438
17439   return (unsigned char *) end;
17440 }
17441
17442 static unsigned char *
17443 display_generic_attribute (unsigned char * start,
17444                            unsigned int tag,
17445                            const unsigned char * const end)
17446 {
17447   if (tag == 0)
17448     return (unsigned char *) end;
17449
17450   return display_tag_value (tag, start, end);
17451 }
17452
17453 static bfd_boolean
17454 process_arch_specific (FILE * file)
17455 {
17456   if (! do_arch)
17457     return TRUE;
17458
17459   switch (elf_header.e_machine)
17460     {
17461     case EM_ARM:
17462       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17463                                  display_arm_attribute,
17464                                  display_generic_attribute);
17465
17466     case EM_MIPS:
17467     case EM_MIPS_RS3_LE:
17468       return process_mips_specific (file);
17469
17470     case EM_MSP430:
17471      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17472                                  display_msp430x_attribute,
17473                                  display_generic_attribute);
17474
17475     case EM_NDS32:
17476       return process_nds32_specific (file);
17477
17478     case EM_PPC:
17479     case EM_PPC64:
17480       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17481                                  display_power_gnu_attribute);
17482
17483     case EM_S390:
17484     case EM_S390_OLD:
17485       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17486                                  display_s390_gnu_attribute);
17487
17488     case EM_SPARC:
17489     case EM_SPARC32PLUS:
17490     case EM_SPARCV9:
17491       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17492                                  display_sparc_gnu_attribute);
17493
17494     case EM_TI_C6000:
17495       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17496                                  display_tic6x_attribute,
17497                                  display_generic_attribute);
17498
17499     default:
17500       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17501                                  display_public_gnu_attributes,
17502                                  display_generic_attribute);
17503     }
17504 }
17505
17506 static bfd_boolean
17507 get_file_header (FILE * file)
17508 {
17509   /* Read in the identity array.  */
17510   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17511     return FALSE;
17512
17513   /* Determine how to read the rest of the header.  */
17514   switch (elf_header.e_ident[EI_DATA])
17515     {
17516     default:
17517     case ELFDATANONE:
17518     case ELFDATA2LSB:
17519       byte_get = byte_get_little_endian;
17520       byte_put = byte_put_little_endian;
17521       break;
17522     case ELFDATA2MSB:
17523       byte_get = byte_get_big_endian;
17524       byte_put = byte_put_big_endian;
17525       break;
17526     }
17527
17528   /* For now we only support 32 bit and 64 bit ELF files.  */
17529   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17530
17531   /* Read in the rest of the header.  */
17532   if (is_32bit_elf)
17533     {
17534       Elf32_External_Ehdr ehdr32;
17535
17536       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17537         return FALSE;
17538
17539       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
17540       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
17541       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
17542       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
17543       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
17544       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
17545       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
17546       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
17547       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17548       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
17549       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17550       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
17551       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
17552     }
17553   else
17554     {
17555       Elf64_External_Ehdr ehdr64;
17556
17557       /* If we have been compiled with sizeof (bfd_vma) == 4, then
17558          we will not be able to cope with the 64bit data found in
17559          64 ELF files.  Detect this now and abort before we start
17560          overwriting things.  */
17561       if (sizeof (bfd_vma) < 8)
17562         {
17563           error (_("This instance of readelf has been built without support for a\n\
17564 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17565           return FALSE;
17566         }
17567
17568       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
17569         return FALSE;
17570
17571       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
17572       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
17573       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
17574       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
17575       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
17576       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
17577       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
17578       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
17579       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17580       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
17581       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17582       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
17583       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
17584     }
17585
17586   if (elf_header.e_shoff)
17587     {
17588       /* There may be some extensions in the first section header.  Don't
17589          bomb if we can't read it.  */
17590       if (is_32bit_elf)
17591         get_32bit_section_headers (file, TRUE);
17592       else
17593         get_64bit_section_headers (file, TRUE);
17594     }
17595
17596   return TRUE;
17597 }
17598
17599 /* Process one ELF object file according to the command line options.
17600    This file may actually be stored in an archive.  The file is
17601    positioned at the start of the ELF object.  Returns TRUE if no
17602    problems were encountered, FALSE otherwise.  */
17603
17604 static bfd_boolean
17605 process_object (char * file_name, FILE * file)
17606 {
17607   unsigned int i;
17608   bfd_boolean res = TRUE;
17609
17610   if (! get_file_header (file))
17611     {
17612       error (_("%s: Failed to read file header\n"), file_name);
17613       return FALSE;
17614     }
17615
17616   /* Initialise per file variables.  */
17617   for (i = ARRAY_SIZE (version_info); i--;)
17618     version_info[i] = 0;
17619
17620   for (i = ARRAY_SIZE (dynamic_info); i--;)
17621     dynamic_info[i] = 0;
17622   dynamic_info_DT_GNU_HASH = 0;
17623
17624   /* Process the file.  */
17625   if (show_name)
17626     printf (_("\nFile: %s\n"), file_name);
17627
17628   /* Initialise the dump_sects array from the cmdline_dump_sects array.
17629      Note we do this even if cmdline_dump_sects is empty because we
17630      must make sure that the dump_sets array is zeroed out before each
17631      object file is processed.  */
17632   if (num_dump_sects > num_cmdline_dump_sects)
17633     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
17634
17635   if (num_cmdline_dump_sects > 0)
17636     {
17637       if (num_dump_sects == 0)
17638         /* A sneaky way of allocating the dump_sects array.  */
17639         request_dump_bynumber (num_cmdline_dump_sects, 0);
17640
17641       assert (num_dump_sects >= num_cmdline_dump_sects);
17642       memcpy (dump_sects, cmdline_dump_sects,
17643               num_cmdline_dump_sects * sizeof (* dump_sects));
17644     }
17645
17646   if (! process_file_header ())
17647     return FALSE;
17648
17649   if (! process_section_headers (file))
17650     {
17651       /* Without loaded section headers we cannot process lots of things.  */
17652       do_unwind = do_version = do_dump = do_arch = FALSE;
17653
17654       if (! do_using_dynamic)
17655         do_syms = do_dyn_syms = do_reloc = FALSE;
17656     }
17657
17658   if (! process_section_groups (file))
17659     /* Without loaded section groups we cannot process unwind.  */
17660     do_unwind = FALSE;
17661
17662   if (process_program_headers (file))
17663     process_dynamic_section (file);
17664   else
17665     res = FALSE;
17666
17667   if (! process_relocs (file))
17668     res = FALSE;
17669
17670   if (! process_unwind (file))
17671     res = FALSE;
17672
17673   if (! process_symbol_table (file))
17674     res = FALSE;
17675
17676   if (! process_syminfo (file))
17677     res = FALSE;
17678
17679   if (! process_version_sections (file))
17680     res = FALSE;
17681
17682   if (! process_section_contents (file))
17683     res = FALSE;
17684
17685   if (! process_notes (file))
17686     res = FALSE;
17687
17688   if (! process_gnu_liblist (file))
17689     res = FALSE;
17690
17691   if (! process_arch_specific (file))
17692     res = FALSE;
17693
17694   if (program_headers)
17695     {
17696       free (program_headers);
17697       program_headers = NULL;
17698     }
17699
17700   if (section_headers)
17701     {
17702       free (section_headers);
17703       section_headers = NULL;
17704     }
17705
17706   if (string_table)
17707     {
17708       free (string_table);
17709       string_table = NULL;
17710       string_table_length = 0;
17711     }
17712
17713   if (dynamic_strings)
17714     {
17715       free (dynamic_strings);
17716       dynamic_strings = NULL;
17717       dynamic_strings_length = 0;
17718     }
17719
17720   if (dynamic_symbols)
17721     {
17722       free (dynamic_symbols);
17723       dynamic_symbols = NULL;
17724       num_dynamic_syms = 0;
17725     }
17726
17727   if (dynamic_syminfo)
17728     {
17729       free (dynamic_syminfo);
17730       dynamic_syminfo = NULL;
17731     }
17732
17733   if (dynamic_section)
17734     {
17735       free (dynamic_section);
17736       dynamic_section = NULL;
17737     }
17738
17739   if (section_headers_groups)
17740     {
17741       free (section_headers_groups);
17742       section_headers_groups = NULL;
17743     }
17744
17745   if (section_groups)
17746     {
17747       struct group_list * g;
17748       struct group_list * next;
17749
17750       for (i = 0; i < group_count; i++)
17751         {
17752           for (g = section_groups [i].root; g != NULL; g = next)
17753             {
17754               next = g->next;
17755               free (g);
17756             }
17757         }
17758
17759       free (section_groups);
17760       section_groups = NULL;
17761     }
17762
17763   free_debug_memory ();
17764
17765   return res;
17766 }
17767
17768 /* Process an ELF archive.
17769    On entry the file is positioned just after the ARMAG string.
17770    Returns TRUE upon success, FALSE otherwise.  */
17771
17772 static bfd_boolean
17773 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17774 {
17775   struct archive_info arch;
17776   struct archive_info nested_arch;
17777   size_t got;
17778   bfd_boolean ret = TRUE;
17779
17780   show_name = TRUE;
17781
17782   /* The ARCH structure is used to hold information about this archive.  */
17783   arch.file_name = NULL;
17784   arch.file = NULL;
17785   arch.index_array = NULL;
17786   arch.sym_table = NULL;
17787   arch.longnames = NULL;
17788
17789   /* The NESTED_ARCH structure is used as a single-item cache of information
17790      about a nested archive (when members of a thin archive reside within
17791      another regular archive file).  */
17792   nested_arch.file_name = NULL;
17793   nested_arch.file = NULL;
17794   nested_arch.index_array = NULL;
17795   nested_arch.sym_table = NULL;
17796   nested_arch.longnames = NULL;
17797
17798   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17799     {
17800       ret = FALSE;
17801       goto out;
17802     }
17803
17804   if (do_archive_index)
17805     {
17806       if (arch.sym_table == NULL)
17807         error (_("%s: unable to dump the index as none was found\n"), file_name);
17808       else
17809         {
17810           unsigned long i, l;
17811           unsigned long current_pos;
17812
17813           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17814                   file_name, (unsigned long) arch.index_num, arch.sym_size);
17815           current_pos = ftell (file);
17816
17817           for (i = l = 0; i < arch.index_num; i++)
17818             {
17819               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17820                 {
17821                   char * member_name;
17822
17823                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17824
17825                   if (member_name != NULL)
17826                     {
17827                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17828
17829                       if (qualified_name != NULL)
17830                         {
17831                           printf (_("Contents of binary %s at offset "), qualified_name);
17832                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
17833                           putchar ('\n');
17834                           free (qualified_name);
17835                         }
17836                     }
17837                 }
17838
17839               if (l >= arch.sym_size)
17840                 {
17841                   error (_("%s: end of the symbol table reached before the end of the index\n"),
17842                          file_name);
17843                   ret = FALSE;
17844                   break;
17845                 }
17846               /* PR 17531: file: 0b6630b2.  */
17847               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17848               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
17849             }
17850
17851           if (arch.uses_64bit_indicies)
17852             l = (l + 7) & ~ 7;
17853           else
17854             l += l & 1;
17855
17856           if (l < arch.sym_size)
17857             {
17858               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17859                      file_name, arch.sym_size - l);
17860               ret = FALSE;
17861             }
17862
17863           if (fseek (file, current_pos, SEEK_SET) != 0)
17864             {
17865               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
17866               ret = FALSE;
17867               goto out;
17868             }
17869         }
17870
17871       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17872           && !do_segments && !do_header && !do_dump && !do_version
17873           && !do_histogram && !do_debugging && !do_arch && !do_notes
17874           && !do_section_groups && !do_dyn_syms)
17875         {
17876           ret = TRUE; /* Archive index only.  */
17877           goto out;
17878         }
17879     }
17880
17881   while (1)
17882     {
17883       char * name;
17884       size_t namelen;
17885       char * qualified_name;
17886
17887       /* Read the next archive header.  */
17888       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17889         {
17890           error (_("%s: failed to seek to next archive header\n"), file_name);
17891           return FALSE;
17892         }
17893       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17894       if (got != sizeof arch.arhdr)
17895         {
17896           if (got == 0)
17897             break;
17898           error (_("%s: failed to read archive header\n"), file_name);
17899           ret = FALSE;
17900           break;
17901         }
17902       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17903         {
17904           error (_("%s: did not find a valid archive header\n"), arch.file_name);
17905           ret = FALSE;
17906           break;
17907         }
17908
17909       arch.next_arhdr_offset += sizeof arch.arhdr;
17910
17911       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17912       if (archive_file_size & 01)
17913         ++archive_file_size;
17914
17915       name = get_archive_member_name (&arch, &nested_arch);
17916       if (name == NULL)
17917         {
17918           error (_("%s: bad archive file name\n"), file_name);
17919           ret = FALSE;
17920           break;
17921         }
17922       namelen = strlen (name);
17923
17924       qualified_name = make_qualified_name (&arch, &nested_arch, name);
17925       if (qualified_name == NULL)
17926         {
17927           error (_("%s: bad archive file name\n"), file_name);
17928           ret = FALSE;
17929           break;
17930         }
17931
17932       if (is_thin_archive && arch.nested_member_origin == 0)
17933         {
17934           /* This is a proxy for an external member of a thin archive.  */
17935           FILE * member_file;
17936           char * member_file_name = adjust_relative_path (file_name, name, namelen);
17937
17938           if (member_file_name == NULL)
17939             {
17940               ret = FALSE;
17941               break;
17942             }
17943
17944           member_file = fopen (member_file_name, "rb");
17945           if (member_file == NULL)
17946             {
17947               error (_("Input file '%s' is not readable.\n"), member_file_name);
17948               free (member_file_name);
17949               ret = FALSE;
17950               break;
17951             }
17952
17953           archive_file_offset = arch.nested_member_origin;
17954
17955           if (! process_object (qualified_name, member_file))
17956             ret = FALSE;
17957
17958           fclose (member_file);
17959           free (member_file_name);
17960         }
17961       else if (is_thin_archive)
17962         {
17963           /* PR 15140: Allow for corrupt thin archives.  */
17964           if (nested_arch.file == NULL)
17965             {
17966               error (_("%s: contains corrupt thin archive: %s\n"),
17967                      file_name, name);
17968               ret = FALSE;
17969               break;
17970             }
17971
17972           /* This is a proxy for a member of a nested archive.  */
17973           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17974
17975           /* The nested archive file will have been opened and setup by
17976              get_archive_member_name.  */
17977           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17978             {
17979               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
17980               ret = FALSE;
17981               break;
17982             }
17983
17984           if (! process_object (qualified_name, nested_arch.file))
17985             ret = FALSE;
17986         }
17987       else
17988         {
17989           archive_file_offset = arch.next_arhdr_offset;
17990           arch.next_arhdr_offset += archive_file_size;
17991
17992           if (! process_object (qualified_name, file))
17993             ret = FALSE;
17994         }
17995
17996       if (dump_sects != NULL)
17997         {
17998           free (dump_sects);
17999           dump_sects = NULL;
18000           num_dump_sects = 0;
18001         }
18002
18003       free (qualified_name);
18004     }
18005
18006  out:
18007   if (nested_arch.file != NULL)
18008     fclose (nested_arch.file);
18009   release_archive (&nested_arch);
18010   release_archive (&arch);
18011
18012   return ret;
18013 }
18014
18015 static bfd_boolean
18016 process_file (char * file_name)
18017 {
18018   FILE * file;
18019   struct stat statbuf;
18020   char armag[SARMAG];
18021   bfd_boolean ret = TRUE;
18022
18023   if (stat (file_name, &statbuf) < 0)
18024     {
18025       if (errno == ENOENT)
18026         error (_("'%s': No such file\n"), file_name);
18027       else
18028         error (_("Could not locate '%s'.  System error message: %s\n"),
18029                file_name, strerror (errno));
18030       return FALSE;
18031     }
18032
18033   if (! S_ISREG (statbuf.st_mode))
18034     {
18035       error (_("'%s' is not an ordinary file\n"), file_name);
18036       return FALSE;
18037     }
18038
18039   file = fopen (file_name, "rb");
18040   if (file == NULL)
18041     {
18042       error (_("Input file '%s' is not readable.\n"), file_name);
18043       return FALSE;
18044     }
18045
18046   if (fread (armag, SARMAG, 1, file) != 1)
18047     {
18048       error (_("%s: Failed to read file's magic number\n"), file_name);
18049       fclose (file);
18050       return FALSE;
18051     }
18052
18053   current_file_size = (bfd_size_type) statbuf.st_size;
18054
18055   if (memcmp (armag, ARMAG, SARMAG) == 0)
18056     {
18057       if (! process_archive (file_name, file, FALSE))
18058         ret = FALSE;
18059     }
18060   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18061     {
18062       if ( ! process_archive (file_name, file, TRUE))
18063         ret = FALSE;
18064     }
18065   else
18066     {
18067       if (do_archive_index)
18068         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18069                file_name);
18070
18071       rewind (file);
18072       archive_file_size = archive_file_offset = 0;
18073
18074       if (! process_object (file_name, file))
18075         ret = FALSE;
18076     }
18077
18078   fclose (file);
18079   current_file_size = 0;
18080
18081   return ret;
18082 }
18083
18084 #ifdef SUPPORT_DISASSEMBLY
18085 /* Needed by the i386 disassembler.  For extra credit, someone could
18086    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18087    symbols.  */
18088
18089 void
18090 print_address (unsigned int addr, FILE * outfile)
18091 {
18092   fprintf (outfile,"0x%8.8x", addr);
18093 }
18094
18095 /* Needed by the i386 disassembler.  */
18096 void
18097 db_task_printsym (unsigned int addr)
18098 {
18099   print_address (addr, stderr);
18100 }
18101 #endif
18102
18103 int
18104 main (int argc, char ** argv)
18105 {
18106   int err;
18107
18108 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18109   setlocale (LC_MESSAGES, "");
18110 #endif
18111 #if defined (HAVE_SETLOCALE)
18112   setlocale (LC_CTYPE, "");
18113 #endif
18114   bindtextdomain (PACKAGE, LOCALEDIR);
18115   textdomain (PACKAGE);
18116
18117   expandargv (&argc, &argv);
18118
18119   parse_args (argc, argv);
18120
18121   if (num_dump_sects > 0)
18122     {
18123       /* Make a copy of the dump_sects array.  */
18124       cmdline_dump_sects = (dump_type *)
18125           malloc (num_dump_sects * sizeof (* dump_sects));
18126       if (cmdline_dump_sects == NULL)
18127         error (_("Out of memory allocating dump request table.\n"));
18128       else
18129         {
18130           memcpy (cmdline_dump_sects, dump_sects,
18131                   num_dump_sects * sizeof (* dump_sects));
18132           num_cmdline_dump_sects = num_dump_sects;
18133         }
18134     }
18135
18136   if (optind < (argc - 1))
18137     show_name = TRUE;
18138   else if (optind >= argc)
18139     {
18140       warn (_("Nothing to do.\n"));
18141       usage (stderr);
18142     }
18143
18144   err = FALSE;
18145   while (optind < argc)
18146     if (! process_file (argv[optind++]))
18147       err = TRUE;
18148
18149   if (dump_sects != NULL)
18150     free (dump_sects);
18151   if (cmdline_dump_sects != NULL)
18152     free (cmdline_dump_sects);
18153
18154   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18155 }