binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2017 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/riscv.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nds32.h"
 135 #include "elf/nios2.h"
 136 #include "elf/or1k.h"
 137 #include "elf/pj.h"
 138 #include "elf/ppc.h"
 139 #include "elf/ppc64.h"
 140 #include "elf/pru.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/wasm32.h"
 155 #include "elf/x86-64.h"
 156 #include "elf/xc16x.h"
 157 #include "elf/xgate.h"
 158 #include "elf/xstormy16.h"
 159 #include "elf/xtensa.h"
 160
 161 #include "getopt.h"
 162 #include "libiberty.h"
 163 #include "safe-ctype.h"
 164 #include "filenames.h"
 165
 166 #ifndef offsetof
 167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 168 #endif
 169
 170 typedef struct elf_section_list
 171 {
 172   Elf_Internal_Shdr * hdr;
 173   struct elf_section_list * next;
 174 } elf_section_list;
 175
 176 char * program_name = "readelf";
 177 static unsigned long archive_file_offset;
 178 static unsigned long archive_file_size;
 179 static bfd_size_type current_file_size;
 180 static unsigned long dynamic_addr;
 181 static bfd_size_type dynamic_size;
 182 static size_t dynamic_nent;
 183 static char * dynamic_strings;
 184 static unsigned long dynamic_strings_length;
 185 static char * string_table;
 186 static unsigned long string_table_length;
 187 static unsigned long num_dynamic_syms;
 188 static Elf_Internal_Sym * dynamic_symbols;
 189 static Elf_Internal_Syminfo * dynamic_syminfo;
 190 static unsigned long dynamic_syminfo_offset;
 191 static unsigned int dynamic_syminfo_nent;
 192 static char program_interpreter[PATH_MAX];
 193 static bfd_vma dynamic_info[DT_ENCODING];
 194 static bfd_vma dynamic_info_DT_GNU_HASH;
 195 static bfd_vma version_info[16];
 196 static Elf_Internal_Ehdr elf_header;
 197 static Elf_Internal_Shdr * section_headers;
 198 static Elf_Internal_Phdr * program_headers;
 199 static Elf_Internal_Dyn *  dynamic_section;
 200 static elf_section_list * symtab_shndx_list;
 201 static bfd_boolean show_name = FALSE;
 202 static bfd_boolean do_dynamic = FALSE;
 203 static bfd_boolean do_syms = FALSE;
 204 static bfd_boolean do_dyn_syms = FALSE;
 205 static bfd_boolean do_reloc = FALSE;
 206 static bfd_boolean do_sections = FALSE;
 207 static bfd_boolean do_section_groups = FALSE;
 208 static bfd_boolean do_section_details = FALSE;
 209 static bfd_boolean do_segments = FALSE;
 210 static bfd_boolean do_unwind = FALSE;
 211 static bfd_boolean do_using_dynamic = FALSE;
 212 static bfd_boolean do_header = FALSE;
 213 static bfd_boolean do_dump = FALSE;
 214 static bfd_boolean do_version = FALSE;
 215 static bfd_boolean do_histogram = FALSE;
 216 static bfd_boolean do_debugging = FALSE;
 217 static bfd_boolean do_arch = FALSE;
 218 static bfd_boolean do_notes = FALSE;
 219 static bfd_boolean do_archive_index = FALSE;
 220 static bfd_boolean is_32bit_elf = FALSE;
 221 static bfd_boolean decompress_dumps = FALSE;
 222
 223 struct group_list
 224 {
 225   struct group_list * next;
 226   unsigned int section_index;
 227 };
 228
 229 struct group
 230 {
 231   struct group_list * root;
 232   unsigned int group_index;
 233 };
 234
 235 static size_t group_count;
 236 static struct group * section_groups;
 237 static struct group ** section_headers_groups;
 238
 239
 240 /* Flag bits indicating particular types of dump.  */
 241 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 242 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 243 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 244 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 245 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 246
 247 typedef unsigned char dump_type;
 248
 249 /* A linked list of the section names for which dumps were requested.  */
 250 struct dump_list_entry
 251 {
 252   char * name;
 253   dump_type type;
 254   struct dump_list_entry * next;
 255 };
 256 static struct dump_list_entry * dump_sects_byname;
 257
 258 /* A dynamic array of flags indicating for which sections a dump
 259    has been requested via command line switches.  */
 260 static dump_type *   cmdline_dump_sects = NULL;
 261 static unsigned int  num_cmdline_dump_sects = 0;
 262
 263 /* A dynamic array of flags indicating for which sections a dump of
 264    some kind has been requested.  It is reset on a per-object file
 265    basis and then initialised from the cmdline_dump_sects array,
 266    the results of interpreting the -w switch, and the
 267    dump_sects_byname list.  */
 268 static dump_type *   dump_sects = NULL;
 269 static unsigned int  num_dump_sects = 0;
 270
 271
 272 /* How to print a vma value.  */
 273 typedef enum print_mode
 274 {
 275   HEX,
 276   DEC,
 277   DEC_5,
 278   UNSIGNED,
 279   PREFIX_HEX,
 280   FULL_HEX,
 281   LONG_HEX
 282 }
 283 print_mode;
 284
 285 /* Versioned symbol info.  */
 286 enum versioned_symbol_info
 287 {
 288   symbol_undefined,
 289   symbol_hidden,
 290   symbol_public
 291 };
 292
 293 static const char * get_symbol_version_string
 294   (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
 295    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 296
 297 #define UNKNOWN -1
 298
 299 #define SECTION_NAME(X)                                         \
 300   ((X) == NULL ? _("<none>")                                    \
 301    : string_table == NULL ? _("<no-name>")                      \
 302    : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \
 303   : string_table + (X)->sh_name))
 304
 305 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 306
 307 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 308   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 309    : get_64bit_elf_symbols (file, section, sym_count))
 310
 311 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 313    already been called and verified that the string exists.  */
 314 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 315
 316 #define REMOVE_ARCH_BITS(ADDR)                  \
 317   do                                            \
 318     {                                           \
 319       if (elf_header.e_machine == EM_ARM)       \
 320         (ADDR) &= ~1;                           \
 321     }                                           \
 322   while (0)
 323 \f
 324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 325    the offset of the current archive member, if we are examining an archive.
 326    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 327    using malloc and fill that.  In either case return the pointer to the start of
 328    the retrieved data or NULL if something went wrong.  If something does go wrong
 329    and REASON is not NULL then emit an error message using REASON as part of the
 330    context.  */
 331
 332 static void *
 333 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 334           bfd_size_type nmemb, const char * reason)
 335 {
 336   void * mvar;
 337   bfd_size_type amt = size * nmemb;
 338
 339   if (size == 0 || nmemb == 0)
 340     return NULL;
 341
 342   /* If the size_t type is smaller than the bfd_size_type, eg because
 343      you are building a 32-bit tool on a 64-bit host, then make sure
 344      that when the sizes are cast to (size_t) no information is lost.  */
 345   if (sizeof (size_t) < sizeof (bfd_size_type)
 346       && (   (bfd_size_type) ((size_t) size) != size
 347           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 348     {
 349       if (reason)
 350         error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
 351                  " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
 352                nmemb, size, reason);
 353       return NULL;
 354     }
 355
 356   /* Check for size overflow.  */
 357   if (amt < nmemb)
 358     {
 359       if (reason)
 360         error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
 361                  " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
 362                nmemb, size, reason);
 363       return NULL;
 364     }
 365
 366   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 367      attempting to allocate memory when the read is bound to fail.  */
 368   if (amt > current_file_size
 369       || offset + archive_file_offset + amt > current_file_size)
 370     {
 371       if (reason)
 372         error (_("Reading 0x%" BFD_VMA_FMT "x"
 373                  " bytes extends past end of file for %s\n"),
 374                amt, reason);
 375       return NULL;
 376     }
 377
 378   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 379     {
 380       if (reason)
 381         error (_("Unable to seek to 0x%lx for %s\n"),
 382                archive_file_offset + offset, reason);
 383       return NULL;
 384     }
 385
 386   mvar = var;
 387   if (mvar == NULL)
 388     {
 389       /* Check for overflow.  */
 390       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 391         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 392         mvar = malloc ((size_t) amt + 1);
 393
 394       if (mvar == NULL)
 395         {
 396           if (reason)
 397             error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
 398                      " bytes for %s\n"),
 399                    amt, reason);
 400           return NULL;
 401         }
 402
 403       ((char *) mvar)[amt] = '\0';
 404     }
 405
 406   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 407     {
 408       if (reason)
 409         error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
 410                amt, reason);
 411       if (mvar != var)
 412         free (mvar);
 413       return NULL;
 414     }
 415
 416   return mvar;
 417 }
 418
 419 /* Print a VMA value in the MODE specified.
 420    Returns the number of characters displayed.  */
 421
 422 static unsigned int
 423 print_vma (bfd_vma vma, print_mode mode)
 424 {
 425   unsigned int nc = 0;
 426
 427   switch (mode)
 428     {
 429     case FULL_HEX:
 430       nc = printf ("0x");
 431       /* Fall through.  */
 432     case LONG_HEX:
 433 #ifdef BFD64
 434       if (is_32bit_elf)
 435         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 436 #endif
 437       printf_vma (vma);
 438       return nc + 16;
 439
 440     case DEC_5:
 441       if (vma <= 99999)
 442         return printf ("%5" BFD_VMA_FMT "d", vma);
 443       /* Fall through.  */
 444     case PREFIX_HEX:
 445       nc = printf ("0x");
 446       /* Fall through.  */
 447     case HEX:
 448       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 449
 450     case DEC:
 451       return printf ("%" BFD_VMA_FMT "d", vma);
 452
 453     case UNSIGNED:
 454       return printf ("%" BFD_VMA_FMT "u", vma);
 455
 456     default:
 457       /* FIXME: Report unrecognised mode ?  */
 458       return 0;
 459     }
 460 }
 461
 462 /* Display a symbol on stdout.  Handles the display of control characters and
 463    multibye characters (assuming the host environment supports them).
 464
 465    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 466
 467    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 468    padding as necessary.
 469
 470    Returns the number of emitted characters.  */
 471
 472 static unsigned int
 473 print_symbol (signed int width, const char *symbol)
 474 {
 475   bfd_boolean extra_padding = FALSE;
 476   signed int num_printed = 0;
 477 #ifdef HAVE_MBSTATE_T
 478   mbstate_t state;
 479 #endif
 480   unsigned int width_remaining;
 481
 482   if (width < 0)
 483     {
 484       /* Keep the width positive.  This helps the code below.  */
 485       width = - width;
 486       extra_padding = TRUE;
 487     }
 488   assert (width != 0);
 489
 490   if (do_wide)
 491     /* Set the remaining width to a very large value.
 492        This simplifies the code below.  */
 493     width_remaining = INT_MAX;
 494   else
 495     width_remaining = width;
 496
 497 #ifdef HAVE_MBSTATE_T
 498   /* Initialise the multibyte conversion state.  */
 499   memset (& state, 0, sizeof (state));
 500 #endif
 501
 502   while (width_remaining)
 503     {
 504       size_t  n;
 505       const char c = *symbol++;
 506
 507       if (c == 0)
 508         break;
 509
 510       /* Do not print control characters directly as they can affect terminal
 511          settings.  Such characters usually appear in the names generated
 512          by the assembler for local labels.  */
 513       if (ISCNTRL (c))
 514         {
 515           if (width_remaining < 2)
 516             break;
 517
 518           printf ("^%c", c + 0x40);
 519           width_remaining -= 2;
 520           num_printed += 2;
 521         }
 522       else if (ISPRINT (c))
 523         {
 524           putchar (c);
 525           width_remaining --;
 526           num_printed ++;
 527         }
 528       else
 529         {
 530 #ifdef HAVE_MBSTATE_T
 531           wchar_t w;
 532 #endif
 533           /* Let printf do the hard work of displaying multibyte characters.  */
 534           printf ("%.1s", symbol - 1);
 535           width_remaining --;
 536           num_printed ++;
 537
 538 #ifdef HAVE_MBSTATE_T
 539           /* Try to find out how many bytes made up the character that was
 540              just printed.  Advance the symbol pointer past the bytes that
 541              were displayed.  */
 542           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 543 #else
 544           n = 1;
 545 #endif
 546           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 547             symbol += (n - 1);
 548         }
 549     }
 550
 551   if (extra_padding && num_printed < width)
 552     {
 553       /* Fill in the remaining spaces.  */
 554       printf ("%-*s", width - num_printed, " ");
 555       num_printed = width;
 556     }
 557
 558   return num_printed;
 559 }
 560
 561 /* Returns a pointer to a static buffer containing a printable version of
 562    the given section's name.  Like print_symbol, except that it does not try
 563    to print multibyte characters, it just interprets them as hex values.  */
 564
 565 static const char *
 566 printable_section_name (const Elf_Internal_Shdr * sec)
 567 {
 568 #define MAX_PRINT_SEC_NAME_LEN 128
 569   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 570   const char * name = SECTION_NAME (sec);
 571   char *       buf = sec_name_buf;
 572   char         c;
 573   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 574
 575   while ((c = * name ++) != 0)
 576     {
 577       if (ISCNTRL (c))
 578         {
 579           if (remaining < 2)
 580             break;
 581
 582           * buf ++ = '^';
 583           * buf ++ = c + 0x40;
 584           remaining -= 2;
 585         }
 586       else if (ISPRINT (c))
 587         {
 588           * buf ++ = c;
 589           remaining -= 1;
 590         }
 591       else
 592         {
 593           static char hex[17] = "0123456789ABCDEF";
 594
 595           if (remaining < 4)
 596             break;
 597           * buf ++ = '<';
 598           * buf ++ = hex[(c & 0xf0) >> 4];
 599           * buf ++ = hex[c & 0x0f];
 600           * buf ++ = '>';
 601           remaining -= 4;
 602         }
 603
 604       if (remaining == 0)
 605         break;
 606     }
 607
 608   * buf = 0;
 609   return sec_name_buf;
 610 }
 611
 612 static const char *
 613 printable_section_name_from_index (unsigned long ndx)
 614 {
 615   if (ndx >= elf_header.e_shnum)
 616     return _("<corrupt>");
 617
 618   return printable_section_name (section_headers + ndx);
 619 }
 620
 621 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 622
 623 static Elf_Internal_Shdr *
 624 find_section (const char * name)
 625 {
 626   unsigned int i;
 627
 628   for (i = 0; i < elf_header.e_shnum; i++)
 629     if (streq (SECTION_NAME (section_headers + i), name))
 630       return section_headers + i;
 631
 632   return NULL;
 633 }
 634
 635 /* Return a pointer to a section containing ADDR, or NULL if no such
 636    section exists.  */
 637
 638 static Elf_Internal_Shdr *
 639 find_section_by_address (bfd_vma addr)
 640 {
 641   unsigned int i;
 642
 643   for (i = 0; i < elf_header.e_shnum; i++)
 644     {
 645       Elf_Internal_Shdr *sec = section_headers + i;
 646       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 647         return sec;
 648     }
 649
 650   return NULL;
 651 }
 652
 653 static Elf_Internal_Shdr *
 654 find_section_by_type (unsigned int type)
 655 {
 656   unsigned int i;
 657
 658   for (i = 0; i < elf_header.e_shnum; i++)
 659     {
 660       Elf_Internal_Shdr *sec = section_headers + i;
 661       if (sec->sh_type == type)
 662         return sec;
 663     }
 664
 665   return NULL;
 666 }
 667
 668 /* Return a pointer to section NAME, or NULL if no such section exists,
 669    restricted to the list of sections given in SET.  */
 670
 671 static Elf_Internal_Shdr *
 672 find_section_in_set (const char * name, unsigned int * set)
 673 {
 674   unsigned int i;
 675
 676   if (set != NULL)
 677     {
 678       while ((i = *set++) > 0)
 679         {
 680           /* See PR 21156 for a reproducer.  */
 681           if (i >= elf_header.e_shnum)
 682             continue; /* FIXME: Should we issue an error message ?  */
 683
 684           if (streq (SECTION_NAME (section_headers + i), name))
 685             return section_headers + i;
 686         }
 687     }
 688
 689   return find_section (name);
 690 }
 691
 692 /* Read an unsigned LEB128 encoded value from DATA.
 693    Set *LENGTH_RETURN to the number of bytes read.  */
 694
 695 static inline unsigned long
 696 read_uleb128 (unsigned char * data,
 697               unsigned int * length_return,
 698               const unsigned char * const end)
 699 {
 700   return read_leb128 (data, length_return, FALSE, end);
 701 }
 702
 703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 704    This OS has so many departures from the ELF standard that we test it at
 705    many places.  */
 706
 707 static inline bfd_boolean
 708 is_ia64_vms (void)
 709 {
 710   return elf_header.e_machine == EM_IA_64
 711     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 712 }
 713
 714 /* Guess the relocation size commonly used by the specific machines.  */
 715
 716 static bfd_boolean
 717 guess_is_rela (unsigned int e_machine)
 718 {
 719   switch (e_machine)
 720     {
 721       /* Targets that use REL relocations.  */
 722     case EM_386:
 723     case EM_IAMCU:
 724     case EM_960:
 725     case EM_ARM:
 726     case EM_D10V:
 727     case EM_CYGNUS_D10V:
 728     case EM_DLX:
 729     case EM_MIPS:
 730     case EM_MIPS_RS3_LE:
 731     case EM_CYGNUS_M32R:
 732     case EM_SCORE:
 733     case EM_XGATE:
 734       return FALSE;
 735
 736       /* Targets that use RELA relocations.  */
 737     case EM_68K:
 738     case EM_860:
 739     case EM_AARCH64:
 740     case EM_ADAPTEVA_EPIPHANY:
 741     case EM_ALPHA:
 742     case EM_ALTERA_NIOS2:
 743     case EM_ARC:
 744     case EM_ARC_COMPACT:
 745     case EM_ARC_COMPACT2:
 746     case EM_AVR:
 747     case EM_AVR_OLD:
 748     case EM_BLACKFIN:
 749     case EM_CR16:
 750     case EM_CRIS:
 751     case EM_CRX:
 752     case EM_D30V:
 753     case EM_CYGNUS_D30V:
 754     case EM_FR30:
 755     case EM_FT32:
 756     case EM_CYGNUS_FR30:
 757     case EM_CYGNUS_FRV:
 758     case EM_H8S:
 759     case EM_H8_300:
 760     case EM_H8_300H:
 761     case EM_IA_64:
 762     case EM_IP2K:
 763     case EM_IP2K_OLD:
 764     case EM_IQ2000:
 765     case EM_LATTICEMICO32:
 766     case EM_M32C_OLD:
 767     case EM_M32C:
 768     case EM_M32R:
 769     case EM_MCORE:
 770     case EM_CYGNUS_MEP:
 771     case EM_METAG:
 772     case EM_MMIX:
 773     case EM_MN10200:
 774     case EM_CYGNUS_MN10200:
 775     case EM_MN10300:
 776     case EM_CYGNUS_MN10300:
 777     case EM_MOXIE:
 778     case EM_MSP430:
 779     case EM_MSP430_OLD:
 780     case EM_MT:
 781     case EM_NDS32:
 782     case EM_NIOS32:
 783     case EM_OR1K:
 784     case EM_PPC64:
 785     case EM_PPC:
 786     case EM_TI_PRU:
 787     case EM_RISCV:
 788     case EM_RL78:
 789     case EM_RX:
 790     case EM_S390:
 791     case EM_S390_OLD:
 792     case EM_SH:
 793     case EM_SPARC:
 794     case EM_SPARC32PLUS:
 795     case EM_SPARCV9:
 796     case EM_SPU:
 797     case EM_TI_C6000:
 798     case EM_TILEGX:
 799     case EM_TILEPRO:
 800     case EM_V800:
 801     case EM_V850:
 802     case EM_CYGNUS_V850:
 803     case EM_VAX:
 804     case EM_VISIUM:
 805     case EM_X86_64:
 806     case EM_L1OM:
 807     case EM_K1OM:
 808     case EM_XSTORMY16:
 809     case EM_XTENSA:
 810     case EM_XTENSA_OLD:
 811     case EM_MICROBLAZE:
 812     case EM_MICROBLAZE_OLD:
 813     case EM_WEBASSEMBLY:
 814       return TRUE;
 815
 816     case EM_68HC05:
 817     case EM_68HC08:
 818     case EM_68HC11:
 819     case EM_68HC16:
 820     case EM_FX66:
 821     case EM_ME16:
 822     case EM_MMA:
 823     case EM_NCPU:
 824     case EM_NDR1:
 825     case EM_PCP:
 826     case EM_ST100:
 827     case EM_ST19:
 828     case EM_ST7:
 829     case EM_ST9PLUS:
 830     case EM_STARCORE:
 831     case EM_SVX:
 832     case EM_TINYJ:
 833     default:
 834       warn (_("Don't know about relocations on this machine architecture\n"));
 835       return FALSE;
 836     }
 837 }
 838
 839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 840    Returns TRUE upon success, FALSE otherwise.  If successful then a
 841    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 842    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 843    responsibility to free the allocated buffer.  */
 844
 845 static bfd_boolean
 846 slurp_rela_relocs (FILE * file,
 847                    unsigned long rel_offset,
 848                    unsigned long rel_size,
 849                    Elf_Internal_Rela ** relasp,
 850                    unsigned long * nrelasp)
 851 {
 852   Elf_Internal_Rela * relas;
 853   size_t nrelas;
 854   unsigned int i;
 855
 856   if (is_32bit_elf)
 857     {
 858       Elf32_External_Rela * erelas;
 859
 860       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 861                                                  rel_size, _("32-bit relocation data"));
 862       if (!erelas)
 863         return FALSE;
 864
 865       nrelas = rel_size / sizeof (Elf32_External_Rela);
 866
 867       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 868                                              sizeof (Elf_Internal_Rela));
 869
 870       if (relas == NULL)
 871         {
 872           free (erelas);
 873           error (_("out of memory parsing relocs\n"));
 874           return FALSE;
 875         }
 876
 877       for (i = 0; i < nrelas; i++)
 878         {
 879           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 880           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 881           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 882         }
 883
 884       free (erelas);
 885     }
 886   else
 887     {
 888       Elf64_External_Rela * erelas;
 889
 890       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 891                                                  rel_size, _("64-bit relocation data"));
 892       if (!erelas)
 893         return FALSE;
 894
 895       nrelas = rel_size / sizeof (Elf64_External_Rela);
 896
 897       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 898                                              sizeof (Elf_Internal_Rela));
 899
 900       if (relas == NULL)
 901         {
 902           free (erelas);
 903           error (_("out of memory parsing relocs\n"));
 904           return FALSE;
 905         }
 906
 907       for (i = 0; i < nrelas; i++)
 908         {
 909           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 910           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 911           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 912
 913           /* The #ifdef BFD64 below is to prevent a compile time
 914              warning.  We know that if we do not have a 64 bit data
 915              type that we will never execute this code anyway.  */
 916 #ifdef BFD64
 917           if (elf_header.e_machine == EM_MIPS
 918               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 919             {
 920               /* In little-endian objects, r_info isn't really a
 921                  64-bit little-endian value: it has a 32-bit
 922                  little-endian symbol index followed by four
 923                  individual byte fields.  Reorder INFO
 924                  accordingly.  */
 925               bfd_vma inf = relas[i].r_info;
 926               inf = (((inf & 0xffffffff) << 32)
 927                       | ((inf >> 56) & 0xff)
 928                       | ((inf >> 40) & 0xff00)
 929                       | ((inf >> 24) & 0xff0000)
 930                       | ((inf >> 8) & 0xff000000));
 931               relas[i].r_info = inf;
 932             }
 933 #endif /* BFD64 */
 934         }
 935
 936       free (erelas);
 937     }
 938
 939   *relasp = relas;
 940   *nrelasp = nrelas;
 941   return TRUE;
 942 }
 943
 944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 945    Returns TRUE upon success, FALSE otherwise.  If successful then a
 946    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 947    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 948    responsibility to free the allocated buffer.  */
 949
 950 static bfd_boolean
 951 slurp_rel_relocs (FILE * file,
 952                   unsigned long rel_offset,
 953                   unsigned long rel_size,
 954                   Elf_Internal_Rela ** relsp,
 955                   unsigned long * nrelsp)
 956 {
 957   Elf_Internal_Rela * rels;
 958   size_t nrels;
 959   unsigned int i;
 960
 961   if (is_32bit_elf)
 962     {
 963       Elf32_External_Rel * erels;
 964
 965       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 966                                                rel_size, _("32-bit relocation data"));
 967       if (!erels)
 968         return FALSE;
 969
 970       nrels = rel_size / sizeof (Elf32_External_Rel);
 971
 972       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 973
 974       if (rels == NULL)
 975         {
 976           free (erels);
 977           error (_("out of memory parsing relocs\n"));
 978           return FALSE;
 979         }
 980
 981       for (i = 0; i < nrels; i++)
 982         {
 983           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
 984           rels[i].r_info   = BYTE_GET (erels[i].r_info);
 985           rels[i].r_addend = 0;
 986         }
 987
 988       free (erels);
 989     }
 990   else
 991     {
 992       Elf64_External_Rel * erels;
 993
 994       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
 995                                                rel_size, _("64-bit relocation data"));
 996       if (!erels)
 997         return FALSE;
 998
 999       nrels = rel_size / sizeof (Elf64_External_Rel);
1000
1001       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1002
1003       if (rels == NULL)
1004         {
1005           free (erels);
1006           error (_("out of memory parsing relocs\n"));
1007           return FALSE;
1008         }
1009
1010       for (i = 0; i < nrels; i++)
1011         {
1012           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1013           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1014           rels[i].r_addend = 0;
1015
1016           /* The #ifdef BFD64 below is to prevent a compile time
1017              warning.  We know that if we do not have a 64 bit data
1018              type that we will never execute this code anyway.  */
1019 #ifdef BFD64
1020           if (elf_header.e_machine == EM_MIPS
1021               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1022             {
1023               /* In little-endian objects, r_info isn't really a
1024                  64-bit little-endian value: it has a 32-bit
1025                  little-endian symbol index followed by four
1026                  individual byte fields.  Reorder INFO
1027                  accordingly.  */
1028               bfd_vma inf = rels[i].r_info;
1029               inf = (((inf & 0xffffffff) << 32)
1030                      | ((inf >> 56) & 0xff)
1031                      | ((inf >> 40) & 0xff00)
1032                      | ((inf >> 24) & 0xff0000)
1033                      | ((inf >> 8) & 0xff000000));
1034               rels[i].r_info = inf;
1035             }
1036 #endif /* BFD64 */
1037         }
1038
1039       free (erels);
1040     }
1041
1042   *relsp = rels;
1043   *nrelsp = nrels;
1044   return TRUE;
1045 }
1046
1047 /* Returns the reloc type extracted from the reloc info field.  */
1048
1049 static unsigned int
1050 get_reloc_type (bfd_vma reloc_info)
1051 {
1052   if (is_32bit_elf)
1053     return ELF32_R_TYPE (reloc_info);
1054
1055   switch (elf_header.e_machine)
1056     {
1057     case EM_MIPS:
1058       /* Note: We assume that reloc_info has already been adjusted for us.  */
1059       return ELF64_MIPS_R_TYPE (reloc_info);
1060
1061     case EM_SPARCV9:
1062       return ELF64_R_TYPE_ID (reloc_info);
1063
1064     default:
1065       return ELF64_R_TYPE (reloc_info);
1066     }
1067 }
1068
1069 /* Return the symbol index extracted from the reloc info field.  */
1070
1071 static bfd_vma
1072 get_reloc_symindex (bfd_vma reloc_info)
1073 {
1074   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1075 }
1076
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1079 {
1080   return
1081     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1082     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1083     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1084         /* TI compiler uses ELFOSABI_NONE.  */
1085         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1086 }
1087
1088 /* Display the contents of the relocation data found at the specified
1089    offset.  */
1090
1091 static bfd_boolean
1092 dump_relocations (FILE * file,
1093                   unsigned long rel_offset,
1094                   unsigned long rel_size,
1095                   Elf_Internal_Sym * symtab,
1096                   unsigned long nsyms,
1097                   char * strtab,
1098                   unsigned long strtablen,
1099                   int is_rela,
1100                   bfd_boolean is_dynsym)
1101 {
1102   unsigned long i;
1103   Elf_Internal_Rela * rels;
1104   bfd_boolean res = TRUE;
1105
1106   if (is_rela == UNKNOWN)
1107     is_rela = guess_is_rela (elf_header.e_machine);
1108
1109   if (is_rela)
1110     {
1111       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1112         return FALSE;
1113     }
1114   else
1115     {
1116       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1117         return FALSE;
1118     }
1119
1120   if (is_32bit_elf)
1121     {
1122       if (is_rela)
1123         {
1124           if (do_wide)
1125             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1126           else
1127             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1128         }
1129       else
1130         {
1131           if (do_wide)
1132             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1133           else
1134             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1135         }
1136     }
1137   else
1138     {
1139       if (is_rela)
1140         {
1141           if (do_wide)
1142             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1143           else
1144             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1145         }
1146       else
1147         {
1148           if (do_wide)
1149             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1150           else
1151             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1152         }
1153     }
1154
1155   for (i = 0; i < rel_size; i++)
1156     {
1157       const char * rtype;
1158       bfd_vma offset;
1159       bfd_vma inf;
1160       bfd_vma symtab_index;
1161       bfd_vma type;
1162
1163       offset = rels[i].r_offset;
1164       inf    = rels[i].r_info;
1165
1166       type = get_reloc_type (inf);
1167       symtab_index = get_reloc_symindex  (inf);
1168
1169       if (is_32bit_elf)
1170         {
1171           printf ("%8.8lx  %8.8lx ",
1172                   (unsigned long) offset & 0xffffffff,
1173                   (unsigned long) inf & 0xffffffff);
1174         }
1175       else
1176         {
1177 #if BFD_HOST_64BIT_LONG
1178           printf (do_wide
1179                   ? "%16.16lx  %16.16lx "
1180                   : "%12.12lx  %12.12lx ",
1181                   offset, inf);
1182 #elif BFD_HOST_64BIT_LONG_LONG
1183 #ifndef __MSVCRT__
1184           printf (do_wide
1185                   ? "%16.16llx  %16.16llx "
1186                   : "%12.12llx  %12.12llx ",
1187                   offset, inf);
1188 #else
1189           printf (do_wide
1190                   ? "%16.16I64x  %16.16I64x "
1191                   : "%12.12I64x  %12.12I64x ",
1192                   offset, inf);
1193 #endif
1194 #else
1195           printf (do_wide
1196                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1197                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1198                   _bfd_int64_high (offset),
1199                   _bfd_int64_low (offset),
1200                   _bfd_int64_high (inf),
1201                   _bfd_int64_low (inf));
1202 #endif
1203         }
1204
1205       switch (elf_header.e_machine)
1206         {
1207         default:
1208           rtype = NULL;
1209           break;
1210
1211         case EM_AARCH64:
1212           rtype = elf_aarch64_reloc_type (type);
1213           break;
1214
1215         case EM_M32R:
1216         case EM_CYGNUS_M32R:
1217           rtype = elf_m32r_reloc_type (type);
1218           break;
1219
1220         case EM_386:
1221         case EM_IAMCU:
1222           rtype = elf_i386_reloc_type (type);
1223           break;
1224
1225         case EM_68HC11:
1226         case EM_68HC12:
1227           rtype = elf_m68hc11_reloc_type (type);
1228           break;
1229
1230         case EM_68K:
1231           rtype = elf_m68k_reloc_type (type);
1232           break;
1233
1234         case EM_960:
1235           rtype = elf_i960_reloc_type (type);
1236           break;
1237
1238         case EM_AVR:
1239         case EM_AVR_OLD:
1240           rtype = elf_avr_reloc_type (type);
1241           break;
1242
1243         case EM_OLD_SPARCV9:
1244         case EM_SPARC32PLUS:
1245         case EM_SPARCV9:
1246         case EM_SPARC:
1247           rtype = elf_sparc_reloc_type (type);
1248           break;
1249
1250         case EM_SPU:
1251           rtype = elf_spu_reloc_type (type);
1252           break;
1253
1254         case EM_V800:
1255           rtype = v800_reloc_type (type);
1256           break;
1257         case EM_V850:
1258         case EM_CYGNUS_V850:
1259           rtype = v850_reloc_type (type);
1260           break;
1261
1262         case EM_D10V:
1263         case EM_CYGNUS_D10V:
1264           rtype = elf_d10v_reloc_type (type);
1265           break;
1266
1267         case EM_D30V:
1268         case EM_CYGNUS_D30V:
1269           rtype = elf_d30v_reloc_type (type);
1270           break;
1271
1272         case EM_DLX:
1273           rtype = elf_dlx_reloc_type (type);
1274           break;
1275
1276         case EM_SH:
1277           rtype = elf_sh_reloc_type (type);
1278           break;
1279
1280         case EM_MN10300:
1281         case EM_CYGNUS_MN10300:
1282           rtype = elf_mn10300_reloc_type (type);
1283           break;
1284
1285         case EM_MN10200:
1286         case EM_CYGNUS_MN10200:
1287           rtype = elf_mn10200_reloc_type (type);
1288           break;
1289
1290         case EM_FR30:
1291         case EM_CYGNUS_FR30:
1292           rtype = elf_fr30_reloc_type (type);
1293           break;
1294
1295         case EM_CYGNUS_FRV:
1296           rtype = elf_frv_reloc_type (type);
1297           break;
1298
1299         case EM_FT32:
1300           rtype = elf_ft32_reloc_type (type);
1301           break;
1302
1303         case EM_MCORE:
1304           rtype = elf_mcore_reloc_type (type);
1305           break;
1306
1307         case EM_MMIX:
1308           rtype = elf_mmix_reloc_type (type);
1309           break;
1310
1311         case EM_MOXIE:
1312           rtype = elf_moxie_reloc_type (type);
1313           break;
1314
1315         case EM_MSP430:
1316           if (uses_msp430x_relocs ())
1317             {
1318               rtype = elf_msp430x_reloc_type (type);
1319               break;
1320             }
1321           /* Fall through.  */
1322         case EM_MSP430_OLD:
1323           rtype = elf_msp430_reloc_type (type);
1324           break;
1325
1326         case EM_NDS32:
1327           rtype = elf_nds32_reloc_type (type);
1328           break;
1329
1330         case EM_PPC:
1331           rtype = elf_ppc_reloc_type (type);
1332           break;
1333
1334         case EM_PPC64:
1335           rtype = elf_ppc64_reloc_type (type);
1336           break;
1337
1338         case EM_MIPS:
1339         case EM_MIPS_RS3_LE:
1340           rtype = elf_mips_reloc_type (type);
1341           break;
1342
1343         case EM_RISCV:
1344           rtype = elf_riscv_reloc_type (type);
1345           break;
1346
1347         case EM_ALPHA:
1348           rtype = elf_alpha_reloc_type (type);
1349           break;
1350
1351         case EM_ARM:
1352           rtype = elf_arm_reloc_type (type);
1353           break;
1354
1355         case EM_ARC:
1356         case EM_ARC_COMPACT:
1357         case EM_ARC_COMPACT2:
1358           rtype = elf_arc_reloc_type (type);
1359           break;
1360
1361         case EM_PARISC:
1362           rtype = elf_hppa_reloc_type (type);
1363           break;
1364
1365         case EM_H8_300:
1366         case EM_H8_300H:
1367         case EM_H8S:
1368           rtype = elf_h8_reloc_type (type);
1369           break;
1370
1371         case EM_OR1K:
1372           rtype = elf_or1k_reloc_type (type);
1373           break;
1374
1375         case EM_PJ:
1376         case EM_PJ_OLD:
1377           rtype = elf_pj_reloc_type (type);
1378           break;
1379         case EM_IA_64:
1380           rtype = elf_ia64_reloc_type (type);
1381           break;
1382
1383         case EM_CRIS:
1384           rtype = elf_cris_reloc_type (type);
1385           break;
1386
1387         case EM_860:
1388           rtype = elf_i860_reloc_type (type);
1389           break;
1390
1391         case EM_X86_64:
1392         case EM_L1OM:
1393         case EM_K1OM:
1394           rtype = elf_x86_64_reloc_type (type);
1395           break;
1396
1397         case EM_S370:
1398           rtype = i370_reloc_type (type);
1399           break;
1400
1401         case EM_S390_OLD:
1402         case EM_S390:
1403           rtype = elf_s390_reloc_type (type);
1404           break;
1405
1406         case EM_SCORE:
1407           rtype = elf_score_reloc_type (type);
1408           break;
1409
1410         case EM_XSTORMY16:
1411           rtype = elf_xstormy16_reloc_type (type);
1412           break;
1413
1414         case EM_CRX:
1415           rtype = elf_crx_reloc_type (type);
1416           break;
1417
1418         case EM_VAX:
1419           rtype = elf_vax_reloc_type (type);
1420           break;
1421
1422         case EM_VISIUM:
1423           rtype = elf_visium_reloc_type (type);
1424           break;
1425
1426         case EM_ADAPTEVA_EPIPHANY:
1427           rtype = elf_epiphany_reloc_type (type);
1428           break;
1429
1430         case EM_IP2K:
1431         case EM_IP2K_OLD:
1432           rtype = elf_ip2k_reloc_type (type);
1433           break;
1434
1435         case EM_IQ2000:
1436           rtype = elf_iq2000_reloc_type (type);
1437           break;
1438
1439         case EM_XTENSA_OLD:
1440         case EM_XTENSA:
1441           rtype = elf_xtensa_reloc_type (type);
1442           break;
1443
1444         case EM_LATTICEMICO32:
1445           rtype = elf_lm32_reloc_type (type);
1446           break;
1447
1448         case EM_M32C_OLD:
1449         case EM_M32C:
1450           rtype = elf_m32c_reloc_type (type);
1451           break;
1452
1453         case EM_MT:
1454           rtype = elf_mt_reloc_type (type);
1455           break;
1456
1457         case EM_BLACKFIN:
1458           rtype = elf_bfin_reloc_type (type);
1459           break;
1460
1461         case EM_CYGNUS_MEP:
1462           rtype = elf_mep_reloc_type (type);
1463           break;
1464
1465         case EM_CR16:
1466           rtype = elf_cr16_reloc_type (type);
1467           break;
1468
1469         case EM_MICROBLAZE:
1470         case EM_MICROBLAZE_OLD:
1471           rtype = elf_microblaze_reloc_type (type);
1472           break;
1473
1474         case EM_RL78:
1475           rtype = elf_rl78_reloc_type (type);
1476           break;
1477
1478         case EM_RX:
1479           rtype = elf_rx_reloc_type (type);
1480           break;
1481
1482         case EM_METAG:
1483           rtype = elf_metag_reloc_type (type);
1484           break;
1485
1486         case EM_XC16X:
1487         case EM_C166:
1488           rtype = elf_xc16x_reloc_type (type);
1489           break;
1490
1491         case EM_TI_C6000:
1492           rtype = elf_tic6x_reloc_type (type);
1493           break;
1494
1495         case EM_TILEGX:
1496           rtype = elf_tilegx_reloc_type (type);
1497           break;
1498
1499         case EM_TILEPRO:
1500           rtype = elf_tilepro_reloc_type (type);
1501           break;
1502
1503         case EM_WEBASSEMBLY:
1504           rtype = elf_wasm32_reloc_type (type);
1505           break;
1506
1507         case EM_XGATE:
1508           rtype = elf_xgate_reloc_type (type);
1509           break;
1510
1511         case EM_ALTERA_NIOS2:
1512           rtype = elf_nios2_reloc_type (type);
1513           break;
1514
1515         case EM_TI_PRU:
1516           rtype = elf_pru_reloc_type (type);
1517           break;
1518         }
1519
1520       if (rtype == NULL)
1521         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1522       else
1523         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1524
1525       if (elf_header.e_machine == EM_ALPHA
1526           && rtype != NULL
1527           && streq (rtype, "R_ALPHA_LITUSE")
1528           && is_rela)
1529         {
1530           switch (rels[i].r_addend)
1531             {
1532             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1533             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1534             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1535             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1536             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1537             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1538             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1539             default: rtype = NULL;
1540             }
1541
1542           if (rtype)
1543             printf (" (%s)", rtype);
1544           else
1545             {
1546               putchar (' ');
1547               printf (_("<unknown addend: %lx>"),
1548                       (unsigned long) rels[i].r_addend);
1549               res = FALSE;
1550             }
1551         }
1552       else if (symtab_index)
1553         {
1554           if (symtab == NULL || symtab_index >= nsyms)
1555             {
1556               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1557               res = FALSE;
1558             }
1559           else
1560             {
1561               Elf_Internal_Sym * psym;
1562               const char * version_string;
1563               enum versioned_symbol_info sym_info;
1564               unsigned short vna_other;
1565
1566               psym = symtab + symtab_index;
1567
1568               version_string
1569                 = get_symbol_version_string (file, is_dynsym,
1570                                              strtab, strtablen,
1571                                              symtab_index,
1572                                              psym,
1573                                              &sym_info,
1574                                              &vna_other);
1575
1576               printf (" ");
1577
1578               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1579                 {
1580                   const char * name;
1581                   unsigned int len;
1582                   unsigned int width = is_32bit_elf ? 8 : 14;
1583
1584                   /* Relocations against GNU_IFUNC symbols do not use the value
1585                      of the symbol as the address to relocate against.  Instead
1586                      they invoke the function named by the symbol and use its
1587                      result as the address for relocation.
1588
1589                      To indicate this to the user, do not display the value of
1590                      the symbol in the "Symbols's Value" field.  Instead show
1591                      its name followed by () as a hint that the symbol is
1592                      invoked.  */
1593
1594                   if (strtab == NULL
1595                       || psym->st_name == 0
1596                       || psym->st_name >= strtablen)
1597                     name = "??";
1598                   else
1599                     name = strtab + psym->st_name;
1600
1601                   len = print_symbol (width, name);
1602                   if (version_string)
1603                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1604                             version_string);
1605                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1606                 }
1607               else
1608                 {
1609                   print_vma (psym->st_value, LONG_HEX);
1610
1611                   printf (is_32bit_elf ? "   " : " ");
1612                 }
1613
1614               if (psym->st_name == 0)
1615                 {
1616                   const char * sec_name = "<null>";
1617                   char name_buf[40];
1618
1619                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1620                     {
1621                       if (psym->st_shndx < elf_header.e_shnum)
1622                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1623                       else if (psym->st_shndx == SHN_ABS)
1624                         sec_name = "ABS";
1625                       else if (psym->st_shndx == SHN_COMMON)
1626                         sec_name = "COMMON";
1627                       else if ((elf_header.e_machine == EM_MIPS
1628                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1629                                || (elf_header.e_machine == EM_TI_C6000
1630                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1631                         sec_name = "SCOMMON";
1632                       else if (elf_header.e_machine == EM_MIPS
1633                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1634                         sec_name = "SUNDEF";
1635                       else if ((elf_header.e_machine == EM_X86_64
1636                                 || elf_header.e_machine == EM_L1OM
1637                                 || elf_header.e_machine == EM_K1OM)
1638                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1639                         sec_name = "LARGE_COMMON";
1640                       else if (elf_header.e_machine == EM_IA_64
1641                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1642                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1643                         sec_name = "ANSI_COM";
1644                       else if (is_ia64_vms ()
1645                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1646                         sec_name = "VMS_SYMVEC";
1647                       else
1648                         {
1649                           sprintf (name_buf, "<section 0x%x>",
1650                                    (unsigned int) psym->st_shndx);
1651                           sec_name = name_buf;
1652                         }
1653                     }
1654                   print_symbol (22, sec_name);
1655                 }
1656               else if (strtab == NULL)
1657                 printf (_("<string table index: %3ld>"), psym->st_name);
1658               else if (psym->st_name >= strtablen)
1659                 {
1660                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1661                   res = FALSE;
1662                 }
1663               else
1664                 {
1665                   print_symbol (22, strtab + psym->st_name);
1666                   if (version_string)
1667                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1668                             version_string);
1669                 }
1670
1671               if (is_rela)
1672                 {
1673                   bfd_vma off = rels[i].r_addend;
1674
1675                   if ((bfd_signed_vma) off < 0)
1676                     printf (" - %" BFD_VMA_FMT "x", - off);
1677                   else
1678                     printf (" + %" BFD_VMA_FMT "x", off);
1679                 }
1680             }
1681         }
1682       else if (is_rela)
1683         {
1684           bfd_vma off = rels[i].r_addend;
1685
1686           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1687           if ((bfd_signed_vma) off < 0)
1688             printf ("-%" BFD_VMA_FMT "x", - off);
1689           else
1690             printf ("%" BFD_VMA_FMT "x", off);
1691         }
1692
1693       if (elf_header.e_machine == EM_SPARCV9
1694           && rtype != NULL
1695           && streq (rtype, "R_SPARC_OLO10"))
1696         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1697
1698       putchar ('\n');
1699
1700 #ifdef BFD64
1701       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1702         {
1703           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1704           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1705           const char * rtype2 = elf_mips_reloc_type (type2);
1706           const char * rtype3 = elf_mips_reloc_type (type3);
1707
1708           printf ("                    Type2: ");
1709
1710           if (rtype2 == NULL)
1711             printf (_("unrecognized: %-7lx"),
1712                     (unsigned long) type2 & 0xffffffff);
1713           else
1714             printf ("%-17.17s", rtype2);
1715
1716           printf ("\n                    Type3: ");
1717
1718           if (rtype3 == NULL)
1719             printf (_("unrecognized: %-7lx"),
1720                     (unsigned long) type3 & 0xffffffff);
1721           else
1722             printf ("%-17.17s", rtype3);
1723
1724           putchar ('\n');
1725         }
1726 #endif /* BFD64 */
1727     }
1728
1729   free (rels);
1730
1731   return res;
1732 }
1733
1734 static const char *
1735 get_mips_dynamic_type (unsigned long type)
1736 {
1737   switch (type)
1738     {
1739     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1740     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1741     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1742     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1743     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1744     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1745     case DT_MIPS_MSYM: return "MIPS_MSYM";
1746     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1747     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1748     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1749     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1750     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1751     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1752     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1753     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1754     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1755     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1756     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1757     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1758     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1759     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1760     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1761     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1762     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1763     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1764     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1765     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1766     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1767     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1768     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1769     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1770     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1771     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1772     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1773     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1774     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1775     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1776     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1777     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1778     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1780     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1781     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1782     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1783     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1784     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1785     default:
1786       return NULL;
1787     }
1788 }
1789
1790 static const char *
1791 get_sparc64_dynamic_type (unsigned long type)
1792 {
1793   switch (type)
1794     {
1795     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1796     default:
1797       return NULL;
1798     }
1799 }
1800
1801 static const char *
1802 get_ppc_dynamic_type (unsigned long type)
1803 {
1804   switch (type)
1805     {
1806     case DT_PPC_GOT:    return "PPC_GOT";
1807     case DT_PPC_OPT:    return "PPC_OPT";
1808     default:
1809       return NULL;
1810     }
1811 }
1812
1813 static const char *
1814 get_ppc64_dynamic_type (unsigned long type)
1815 {
1816   switch (type)
1817     {
1818     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1819     case DT_PPC64_OPD:    return "PPC64_OPD";
1820     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1821     case DT_PPC64_OPT:    return "PPC64_OPT";
1822     default:
1823       return NULL;
1824     }
1825 }
1826
1827 static const char *
1828 get_parisc_dynamic_type (unsigned long type)
1829 {
1830   switch (type)
1831     {
1832     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1833     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1834     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1835     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1836     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1837     case DT_HP_PREINIT:         return "HP_PREINIT";
1838     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1839     case DT_HP_NEEDED:          return "HP_NEEDED";
1840     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1841     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1842     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1843     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1844     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1845     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1846     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1847     case DT_HP_FILTERED:        return "HP_FILTERED";
1848     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1849     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1850     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1851     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1852     case DT_PLT:                return "PLT";
1853     case DT_PLT_SIZE:           return "PLT_SIZE";
1854     case DT_DLT:                return "DLT";
1855     case DT_DLT_SIZE:           return "DLT_SIZE";
1856     default:
1857       return NULL;
1858     }
1859 }
1860
1861 static const char *
1862 get_ia64_dynamic_type (unsigned long type)
1863 {
1864   switch (type)
1865     {
1866     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1867     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1868     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1869     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1870     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1871     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1872     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1873     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1874     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1875     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1876     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1877     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1878     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1879     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1880     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1881     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1882     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1883     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1884     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1885     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1886     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1887     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1888     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1889     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1890     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1891     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1892     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1893     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1894     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1895     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1896     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1897     default:
1898       return NULL;
1899     }
1900 }
1901
1902 static const char *
1903 get_solaris_section_type (unsigned long type)
1904 {
1905   switch (type)
1906     {
1907     case 0x6fffffee: return "SUNW_ancillary";
1908     case 0x6fffffef: return "SUNW_capchain";
1909     case 0x6ffffff0: return "SUNW_capinfo";
1910     case 0x6ffffff1: return "SUNW_symsort";
1911     case 0x6ffffff2: return "SUNW_tlssort";
1912     case 0x6ffffff3: return "SUNW_LDYNSYM";
1913     case 0x6ffffff4: return "SUNW_dof";
1914     case 0x6ffffff5: return "SUNW_cap";
1915     case 0x6ffffff6: return "SUNW_SIGNATURE";
1916     case 0x6ffffff7: return "SUNW_ANNOTATE";
1917     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918     case 0x6ffffff9: return "SUNW_DEBUG";
1919     case 0x6ffffffa: return "SUNW_move";
1920     case 0x6ffffffb: return "SUNW_COMDAT";
1921     case 0x6ffffffc: return "SUNW_syminfo";
1922     case 0x6ffffffd: return "SUNW_verdef";
1923     case 0x6ffffffe: return "SUNW_verneed";
1924     case 0x6fffffff: return "SUNW_versym";
1925     case 0x70000000: return "SPARC_GOTDATA";
1926     default: return NULL;
1927     }
1928 }
1929
1930 static const char *
1931 get_alpha_dynamic_type (unsigned long type)
1932 {
1933   switch (type)
1934     {
1935     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1936     default: return NULL;
1937     }
1938 }
1939
1940 static const char *
1941 get_score_dynamic_type (unsigned long type)
1942 {
1943   switch (type)
1944     {
1945     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1946     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1947     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1948     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1949     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1950     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1951     default:                    return NULL;
1952     }
1953 }
1954
1955 static const char *
1956 get_tic6x_dynamic_type (unsigned long type)
1957 {
1958   switch (type)
1959     {
1960     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1961     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1962     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1963     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1964     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1965     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1966     default:                   return NULL;
1967     }
1968 }
1969
1970 static const char *
1971 get_nios2_dynamic_type (unsigned long type)
1972 {
1973   switch (type)
1974     {
1975     case DT_NIOS2_GP: return "NIOS2_GP";
1976     default:          return NULL;
1977     }
1978 }
1979
1980 static const char *
1981 get_solaris_dynamic_type (unsigned long type)
1982 {
1983   switch (type)
1984     {
1985     case 0x6000000d: return "SUNW_AUXILIARY";
1986     case 0x6000000e: return "SUNW_RTLDINF";
1987     case 0x6000000f: return "SUNW_FILTER";
1988     case 0x60000010: return "SUNW_CAP";
1989     case 0x60000011: return "SUNW_SYMTAB";
1990     case 0x60000012: return "SUNW_SYMSZ";
1991     case 0x60000013: return "SUNW_SORTENT";
1992     case 0x60000014: return "SUNW_SYMSORT";
1993     case 0x60000015: return "SUNW_SYMSORTSZ";
1994     case 0x60000016: return "SUNW_TLSSORT";
1995     case 0x60000017: return "SUNW_TLSSORTSZ";
1996     case 0x60000018: return "SUNW_CAPINFO";
1997     case 0x60000019: return "SUNW_STRPAD";
1998     case 0x6000001a: return "SUNW_CAPCHAIN";
1999     case 0x6000001b: return "SUNW_LDMACH";
2000     case 0x6000001d: return "SUNW_CAPCHAINENT";
2001     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002     case 0x60000021: return "SUNW_PARENT";
2003     case 0x60000023: return "SUNW_ASLR";
2004     case 0x60000025: return "SUNW_RELAX";
2005     case 0x60000029: return "SUNW_NXHEAP";
2006     case 0x6000002b: return "SUNW_NXSTACK";
2007
2008     case 0x70000001: return "SPARC_REGISTER";
2009     case 0x7ffffffd: return "AUXILIARY";
2010     case 0x7ffffffe: return "USED";
2011     case 0x7fffffff: return "FILTER";
2012
2013     default: return NULL;
2014     }
2015 }
2016
2017 static const char *
2018 get_dynamic_type (unsigned long type)
2019 {
2020   static char buff[64];
2021
2022   switch (type)
2023     {
2024     case DT_NULL:       return "NULL";
2025     case DT_NEEDED:     return "NEEDED";
2026     case DT_PLTRELSZ:   return "PLTRELSZ";
2027     case DT_PLTGOT:     return "PLTGOT";
2028     case DT_HASH:       return "HASH";
2029     case DT_STRTAB:     return "STRTAB";
2030     case DT_SYMTAB:     return "SYMTAB";
2031     case DT_RELA:       return "RELA";
2032     case DT_RELASZ:     return "RELASZ";
2033     case DT_RELAENT:    return "RELAENT";
2034     case DT_STRSZ:      return "STRSZ";
2035     case DT_SYMENT:     return "SYMENT";
2036     case DT_INIT:       return "INIT";
2037     case DT_FINI:       return "FINI";
2038     case DT_SONAME:     return "SONAME";
2039     case DT_RPATH:      return "RPATH";
2040     case DT_SYMBOLIC:   return "SYMBOLIC";
2041     case DT_REL:        return "REL";
2042     case DT_RELSZ:      return "RELSZ";
2043     case DT_RELENT:     return "RELENT";
2044     case DT_PLTREL:     return "PLTREL";
2045     case DT_DEBUG:      return "DEBUG";
2046     case DT_TEXTREL:    return "TEXTREL";
2047     case DT_JMPREL:     return "JMPREL";
2048     case DT_BIND_NOW:   return "BIND_NOW";
2049     case DT_INIT_ARRAY: return "INIT_ARRAY";
2050     case DT_FINI_ARRAY: return "FINI_ARRAY";
2051     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2052     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2053     case DT_RUNPATH:    return "RUNPATH";
2054     case DT_FLAGS:      return "FLAGS";
2055
2056     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2057     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2058     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2059
2060     case DT_CHECKSUM:   return "CHECKSUM";
2061     case DT_PLTPADSZ:   return "PLTPADSZ";
2062     case DT_MOVEENT:    return "MOVEENT";
2063     case DT_MOVESZ:     return "MOVESZ";
2064     case DT_FEATURE:    return "FEATURE";
2065     case DT_POSFLAG_1:  return "POSFLAG_1";
2066     case DT_SYMINSZ:    return "SYMINSZ";
2067     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2068
2069     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2070     case DT_CONFIG:     return "CONFIG";
2071     case DT_DEPAUDIT:   return "DEPAUDIT";
2072     case DT_AUDIT:      return "AUDIT";
2073     case DT_PLTPAD:     return "PLTPAD";
2074     case DT_MOVETAB:    return "MOVETAB";
2075     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2076
2077     case DT_VERSYM:     return "VERSYM";
2078
2079     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2080     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2081     case DT_RELACOUNT:  return "RELACOUNT";
2082     case DT_RELCOUNT:   return "RELCOUNT";
2083     case DT_FLAGS_1:    return "FLAGS_1";
2084     case DT_VERDEF:     return "VERDEF";
2085     case DT_VERDEFNUM:  return "VERDEFNUM";
2086     case DT_VERNEED:    return "VERNEED";
2087     case DT_VERNEEDNUM: return "VERNEEDNUM";
2088
2089     case DT_AUXILIARY:  return "AUXILIARY";
2090     case DT_USED:       return "USED";
2091     case DT_FILTER:     return "FILTER";
2092
2093     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2094     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2095     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2096     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2097     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2098     case DT_GNU_HASH:   return "GNU_HASH";
2099
2100     default:
2101       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2102         {
2103           const char * result;
2104
2105           switch (elf_header.e_machine)
2106             {
2107             case EM_MIPS:
2108             case EM_MIPS_RS3_LE:
2109               result = get_mips_dynamic_type (type);
2110               break;
2111             case EM_SPARCV9:
2112               result = get_sparc64_dynamic_type (type);
2113               break;
2114             case EM_PPC:
2115               result = get_ppc_dynamic_type (type);
2116               break;
2117             case EM_PPC64:
2118               result = get_ppc64_dynamic_type (type);
2119               break;
2120             case EM_IA_64:
2121               result = get_ia64_dynamic_type (type);
2122               break;
2123             case EM_ALPHA:
2124               result = get_alpha_dynamic_type (type);
2125               break;
2126             case EM_SCORE:
2127               result = get_score_dynamic_type (type);
2128               break;
2129             case EM_TI_C6000:
2130               result = get_tic6x_dynamic_type (type);
2131               break;
2132             case EM_ALTERA_NIOS2:
2133               result = get_nios2_dynamic_type (type);
2134               break;
2135             default:
2136               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2137                 result = get_solaris_dynamic_type (type);
2138               else
2139                 result = NULL;
2140               break;
2141             }
2142
2143           if (result != NULL)
2144             return result;
2145
2146           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2147         }
2148       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2149                || (elf_header.e_machine == EM_PARISC
2150                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2151         {
2152           const char * result;
2153
2154           switch (elf_header.e_machine)
2155             {
2156             case EM_PARISC:
2157               result = get_parisc_dynamic_type (type);
2158               break;
2159             case EM_IA_64:
2160               result = get_ia64_dynamic_type (type);
2161               break;
2162             default:
2163               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2164                 result = get_solaris_dynamic_type (type);
2165               else
2166                 result = NULL;
2167               break;
2168             }
2169
2170           if (result != NULL)
2171             return result;
2172
2173           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2174                     type);
2175         }
2176       else
2177         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2178
2179       return buff;
2180     }
2181 }
2182
2183 static char *
2184 get_file_type (unsigned e_type)
2185 {
2186   static char buff[32];
2187
2188   switch (e_type)
2189     {
2190     case ET_NONE: return _("NONE (None)");
2191     case ET_REL:  return _("REL (Relocatable file)");
2192     case ET_EXEC: return _("EXEC (Executable file)");
2193     case ET_DYN:  return _("DYN (Shared object file)");
2194     case ET_CORE: return _("CORE (Core file)");
2195
2196     default:
2197       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2198         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2199       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2200         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2201       else
2202         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2203       return buff;
2204     }
2205 }
2206
2207 static char *
2208 get_machine_name (unsigned e_machine)
2209 {
2210   static char buff[64]; /* XXX */
2211
2212   switch (e_machine)
2213     {
2214       /* Please keep this switch table sorted by increasing EM_ value.  */
2215       /* 0 */
2216     case EM_NONE:               return _("None");
2217     case EM_M32:                return "WE32100";
2218     case EM_SPARC:              return "Sparc";
2219     case EM_386:                return "Intel 80386";
2220     case EM_68K:                return "MC68000";
2221     case EM_88K:                return "MC88000";
2222     case EM_IAMCU:              return "Intel MCU";
2223     case EM_860:                return "Intel 80860";
2224     case EM_MIPS:               return "MIPS R3000";
2225     case EM_S370:               return "IBM System/370";
2226       /* 10 */
2227     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2228     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2229     case EM_PARISC:             return "HPPA";
2230     case EM_VPP550:             return "Fujitsu VPP500";
2231     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2232     case EM_960:                return "Intel 90860";
2233     case EM_PPC:                return "PowerPC";
2234       /* 20 */
2235     case EM_PPC64:              return "PowerPC64";
2236     case EM_S390_OLD:
2237     case EM_S390:               return "IBM S/390";
2238     case EM_SPU:                return "SPU";
2239       /* 30 */
2240     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2241     case EM_FR20:               return "Fujitsu FR20";
2242     case EM_RH32:               return "TRW RH32";
2243     case EM_MCORE:              return "MCORE";
2244       /* 40 */
2245     case EM_ARM:                return "ARM";
2246     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2247     case EM_SH:                 return "Renesas / SuperH SH";
2248     case EM_SPARCV9:            return "Sparc v9";
2249     case EM_TRICORE:            return "Siemens Tricore";
2250     case EM_ARC:                return "ARC";
2251     case EM_H8_300:             return "Renesas H8/300";
2252     case EM_H8_300H:            return "Renesas H8/300H";
2253     case EM_H8S:                return "Renesas H8S";
2254     case EM_H8_500:             return "Renesas H8/500";
2255       /* 50 */
2256     case EM_IA_64:              return "Intel IA-64";
2257     case EM_MIPS_X:             return "Stanford MIPS-X";
2258     case EM_COLDFIRE:           return "Motorola Coldfire";
2259     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2260     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2261     case EM_PCP:                return "Siemens PCP";
2262     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2263     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2264     case EM_STARCORE:           return "Motorola Star*Core processor";
2265     case EM_ME16:               return "Toyota ME16 processor";
2266       /* 60 */
2267     case EM_ST100:              return "STMicroelectronics ST100 processor";
2268     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2269     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2270     case EM_PDSP:               return "Sony DSP processor";
2271     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2272     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2273     case EM_FX66:               return "Siemens FX66 microcontroller";
2274     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2276     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2277       /* 70 */
2278     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2279     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2280     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2281     case EM_SVX:                return "Silicon Graphics SVx";
2282     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2283     case EM_VAX:                return "Digital VAX";
2284     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2285     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2286     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2287     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2288       /* 80 */
2289     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2290     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2291     case EM_PRISM:              return "Vitesse Prism";
2292     case EM_AVR_OLD:
2293     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2294     case EM_CYGNUS_FR30:
2295     case EM_FR30:               return "Fujitsu FR30";
2296     case EM_CYGNUS_D10V:
2297     case EM_D10V:               return "d10v";
2298     case EM_CYGNUS_D30V:
2299     case EM_D30V:               return "d30v";
2300     case EM_CYGNUS_V850:
2301     case EM_V850:               return "Renesas V850";
2302     case EM_CYGNUS_M32R:
2303     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2304     case EM_CYGNUS_MN10300:
2305     case EM_MN10300:            return "mn10300";
2306       /* 90 */
2307     case EM_CYGNUS_MN10200:
2308     case EM_MN10200:            return "mn10200";
2309     case EM_PJ:                 return "picoJava";
2310     case EM_OR1K:               return "OpenRISC 1000";
2311     case EM_ARC_COMPACT:        return "ARCompact";
2312     case EM_XTENSA_OLD:
2313     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2314     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2315     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2316     case EM_NS32K:              return "National Semiconductor 32000 series";
2317     case EM_TPC:                return "Tenor Network TPC processor";
2318     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2319       /* 100 */
2320     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2321     case EM_IP2K_OLD:
2322     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2323     case EM_MAX:                return "MAX Processor";
2324     case EM_CR:                 return "National Semiconductor CompactRISC";
2325     case EM_F2MC16:             return "Fujitsu F2MC16";
2326     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2327     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2328     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2329     case EM_SEP:                return "Sharp embedded microprocessor";
2330     case EM_ARCA:               return "Arca RISC microprocessor";
2331       /* 110 */
2332     case EM_UNICORE:            return "Unicore";
2333     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2334     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2335     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2336     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2337     case EM_XGATE:              return "Motorola XGATE embedded processor";
2338     case EM_C166:
2339     case EM_XC16X:              return "Infineon Technologies xc16x";
2340     case EM_M16C:               return "Renesas M16C series microprocessors";
2341     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2342     case EM_CE:                 return "Freescale Communication Engine RISC core";
2343       /* 120 */
2344     case EM_M32C:               return "Renesas M32c";
2345       /* 130 */
2346     case EM_TSK3000:            return "Altium TSK3000 core";
2347     case EM_RS08:               return "Freescale RS08 embedded processor";
2348     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2349     case EM_SCORE:              return "SUNPLUS S+Core";
2350     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2351     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2352     case EM_LATTICEMICO32:      return "Lattice Mico32";
2353     case EM_SE_C17:             return "Seiko Epson C17 family";
2354       /* 140 */
2355     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2356     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2357     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2358     case EM_TI_PRU:             return "TI PRU I/O processor";
2359       /* 160 */
2360     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2362     case EM_R32C:               return "Renesas R32C series microprocessors";
2363     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2364     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2365     case EM_8051:               return "Intel 8051 and variants";
2366     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2367     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2368     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2369     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2370       /* 170 */
2371     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2372     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2373     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2374     case EM_RX:                 return "Renesas RX";
2375     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2376     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2377     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2378     case EM_CR16:
2379     case EM_MICROBLAZE:
2380     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2381     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2382     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2383       /* 180 */
2384     case EM_L1OM:               return "Intel L1OM";
2385     case EM_K1OM:               return "Intel K1OM";
2386     case EM_INTEL182:           return "Intel (reserved)";
2387     case EM_AARCH64:            return "AArch64";
2388     case EM_ARM184:             return "ARM (reserved)";
2389     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2390     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2391     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2392     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2393       /* 190 */
2394     case EM_CUDA:               return "NVIDIA CUDA architecture";
2395     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2396     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2397     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2398     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2399     case EM_ARC_COMPACT2:       return "ARCv2";
2400     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2401     case EM_RL78:               return "Renesas RL78";
2402     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2403     case EM_78K0R:              return "Renesas 78K0R";
2404       /* 200 */
2405     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2406     case EM_BA1:                return "Beyond BA1 CPU architecture";
2407     case EM_BA2:                return "Beyond BA2 CPU architecture";
2408     case EM_XCORE:              return "XMOS xCORE processor family";
2409     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2410       /* 210 */
2411     case EM_KM32:               return "KM211 KM32 32-bit processor";
2412     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2413     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2414     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2415     case EM_KVARC:              return "KM211 KVARC processor";
2416     case EM_CDP:                return "Paneve CDP architecture family";
2417     case EM_COGE:               return "Cognitive Smart Memory Processor";
2418     case EM_COOL:               return "Bluechip Systems CoolEngine";
2419     case EM_NORC:               return "Nanoradio Optimized RISC";
2420     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2421       /* 220 */
2422     case EM_Z80:                return "Zilog Z80";
2423     case EM_VISIUM:             return "CDS VISIUMcore processor";
2424     case EM_FT32:               return "FTDI Chip FT32";
2425     case EM_MOXIE:              return "Moxie";
2426     case EM_AMDGPU:             return "AMD GPU";
2427     case EM_RISCV:              return "RISC-V";
2428     case EM_LANAI:              return "Lanai 32-bit processor";
2429     case EM_BPF:                return "Linux BPF";
2430
2431       /* Large numbers...  */
2432     case EM_MT:                 return "Morpho Techologies MT processor";
2433     case EM_ALPHA:              return "Alpha";
2434     case EM_WEBASSEMBLY:        return "Web Assembly";
2435     case EM_DLX:                return "OpenDLX";
2436     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2437     case EM_IQ2000:             return "Vitesse IQ2000";
2438     case EM_M32C_OLD:
2439     case EM_NIOS32:             return "Altera Nios";
2440     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2441     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2442     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2443
2444     default:
2445       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2446       return buff;
2447     }
2448 }
2449
2450 static void
2451 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2452 {
2453   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2454      other compilers don't a specific architecture type in the e_flags, and
2455      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2457      architectures.
2458
2459      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460      but also sets a specific architecture type in the e_flags field.
2461
2462      However, when decoding the flags we don't worry if we see an
2463      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464      ARCEM architecture type.  */
2465
2466   switch (e_flags & EF_ARC_MACH_MSK)
2467     {
2468       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2469     case EF_ARC_CPU_ARCV2EM:
2470       strcat (buf, ", ARC EM");
2471       break;
2472     case EF_ARC_CPU_ARCV2HS:
2473       strcat (buf, ", ARC HS");
2474       break;
2475
2476       /* We only expect these to occur for EM_ARC_COMPACT.  */
2477     case E_ARC_MACH_ARC600:
2478       strcat (buf, ", ARC600");
2479       break;
2480     case E_ARC_MACH_ARC601:
2481       strcat (buf, ", ARC601");
2482       break;
2483     case E_ARC_MACH_ARC700:
2484       strcat (buf, ", ARC700");
2485       break;
2486
2487       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488          new ELF with new architecture being read by an old version of
2489          readelf, or (c) An ELF built with non-GNU compiler that does not
2490          set the architecture in the e_flags.  */
2491     default:
2492       if (e_machine == EM_ARC_COMPACT)
2493         strcat (buf, ", Unknown ARCompact");
2494       else
2495         strcat (buf, ", Unknown ARC");
2496       break;
2497     }
2498
2499   switch (e_flags & EF_ARC_OSABI_MSK)
2500     {
2501     case E_ARC_OSABI_ORIG:
2502       strcat (buf, ", (ABI:legacy)");
2503       break;
2504     case E_ARC_OSABI_V2:
2505       strcat (buf, ", (ABI:v2)");
2506       break;
2507       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2508     case E_ARC_OSABI_V3:
2509       strcat (buf, ", v3 no-legacy-syscalls ABI");
2510       break;
2511     case E_ARC_OSABI_V4:
2512       strcat (buf, ", v4 ABI");
2513       break;
2514     default:
2515       strcat (buf, ", unrecognised ARC OSABI flag");
2516       break;
2517     }
2518 }
2519
2520 static void
2521 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2522 {
2523   unsigned eabi;
2524   bfd_boolean unknown = FALSE;
2525
2526   eabi = EF_ARM_EABI_VERSION (e_flags);
2527   e_flags &= ~ EF_ARM_EABIMASK;
2528
2529   /* Handle "generic" ARM flags.  */
2530   if (e_flags & EF_ARM_RELEXEC)
2531     {
2532       strcat (buf, ", relocatable executable");
2533       e_flags &= ~ EF_ARM_RELEXEC;
2534     }
2535
2536   /* Now handle EABI specific flags.  */
2537   switch (eabi)
2538     {
2539     default:
2540       strcat (buf, ", <unrecognized EABI>");
2541       if (e_flags)
2542         unknown = TRUE;
2543       break;
2544
2545     case EF_ARM_EABI_VER1:
2546       strcat (buf, ", Version1 EABI");
2547       while (e_flags)
2548         {
2549           unsigned flag;
2550
2551           /* Process flags one bit at a time.  */
2552           flag = e_flags & - e_flags;
2553           e_flags &= ~ flag;
2554
2555           switch (flag)
2556             {
2557             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2558               strcat (buf, ", sorted symbol tables");
2559               break;
2560
2561             default:
2562               unknown = TRUE;
2563               break;
2564             }
2565         }
2566       break;
2567
2568     case EF_ARM_EABI_VER2:
2569       strcat (buf, ", Version2 EABI");
2570       while (e_flags)
2571         {
2572           unsigned flag;
2573
2574           /* Process flags one bit at a time.  */
2575           flag = e_flags & - e_flags;
2576           e_flags &= ~ flag;
2577
2578           switch (flag)
2579             {
2580             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2581               strcat (buf, ", sorted symbol tables");
2582               break;
2583
2584             case EF_ARM_DYNSYMSUSESEGIDX:
2585               strcat (buf, ", dynamic symbols use segment index");
2586               break;
2587
2588             case EF_ARM_MAPSYMSFIRST:
2589               strcat (buf, ", mapping symbols precede others");
2590               break;
2591
2592             default:
2593               unknown = TRUE;
2594               break;
2595             }
2596         }
2597       break;
2598
2599     case EF_ARM_EABI_VER3:
2600       strcat (buf, ", Version3 EABI");
2601       break;
2602
2603     case EF_ARM_EABI_VER4:
2604       strcat (buf, ", Version4 EABI");
2605       while (e_flags)
2606         {
2607           unsigned flag;
2608
2609           /* Process flags one bit at a time.  */
2610           flag = e_flags & - e_flags;
2611           e_flags &= ~ flag;
2612
2613           switch (flag)
2614             {
2615             case EF_ARM_BE8:
2616               strcat (buf, ", BE8");
2617               break;
2618
2619             case EF_ARM_LE8:
2620               strcat (buf, ", LE8");
2621               break;
2622
2623             default:
2624               unknown = TRUE;
2625               break;
2626             }
2627         }
2628       break;
2629
2630     case EF_ARM_EABI_VER5:
2631       strcat (buf, ", Version5 EABI");
2632       while (e_flags)
2633         {
2634           unsigned flag;
2635
2636           /* Process flags one bit at a time.  */
2637           flag = e_flags & - e_flags;
2638           e_flags &= ~ flag;
2639
2640           switch (flag)
2641             {
2642             case EF_ARM_BE8:
2643               strcat (buf, ", BE8");
2644               break;
2645
2646             case EF_ARM_LE8:
2647               strcat (buf, ", LE8");
2648               break;
2649
2650             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2651               strcat (buf, ", soft-float ABI");
2652               break;
2653
2654             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2655               strcat (buf, ", hard-float ABI");
2656               break;
2657
2658             default:
2659               unknown = TRUE;
2660               break;
2661             }
2662         }
2663       break;
2664
2665     case EF_ARM_EABI_UNKNOWN:
2666       strcat (buf, ", GNU EABI");
2667       while (e_flags)
2668         {
2669           unsigned flag;
2670
2671           /* Process flags one bit at a time.  */
2672           flag = e_flags & - e_flags;
2673           e_flags &= ~ flag;
2674
2675           switch (flag)
2676             {
2677             case EF_ARM_INTERWORK:
2678               strcat (buf, ", interworking enabled");
2679               break;
2680
2681             case EF_ARM_APCS_26:
2682               strcat (buf, ", uses APCS/26");
2683               break;
2684
2685             case EF_ARM_APCS_FLOAT:
2686               strcat (buf, ", uses APCS/float");
2687               break;
2688
2689             case EF_ARM_PIC:
2690               strcat (buf, ", position independent");
2691               break;
2692
2693             case EF_ARM_ALIGN8:
2694               strcat (buf, ", 8 bit structure alignment");
2695               break;
2696
2697             case EF_ARM_NEW_ABI:
2698               strcat (buf, ", uses new ABI");
2699               break;
2700
2701             case EF_ARM_OLD_ABI:
2702               strcat (buf, ", uses old ABI");
2703               break;
2704
2705             case EF_ARM_SOFT_FLOAT:
2706               strcat (buf, ", software FP");
2707               break;
2708
2709             case EF_ARM_VFP_FLOAT:
2710               strcat (buf, ", VFP");
2711               break;
2712
2713             case EF_ARM_MAVERICK_FLOAT:
2714               strcat (buf, ", Maverick FP");
2715               break;
2716
2717             default:
2718               unknown = TRUE;
2719               break;
2720             }
2721         }
2722     }
2723
2724   if (unknown)
2725     strcat (buf,_(", <unknown>"));
2726 }
2727
2728 static void
2729 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2730 {
2731   --size; /* Leave space for null terminator.  */
2732
2733   switch (e_flags & EF_AVR_MACH)
2734     {
2735     case E_AVR_MACH_AVR1:
2736       strncat (buf, ", avr:1", size);
2737       break;
2738     case E_AVR_MACH_AVR2:
2739       strncat (buf, ", avr:2", size);
2740       break;
2741     case E_AVR_MACH_AVR25:
2742       strncat (buf, ", avr:25", size);
2743       break;
2744     case E_AVR_MACH_AVR3:
2745       strncat (buf, ", avr:3", size);
2746       break;
2747     case E_AVR_MACH_AVR31:
2748       strncat (buf, ", avr:31", size);
2749       break;
2750     case E_AVR_MACH_AVR35:
2751       strncat (buf, ", avr:35", size);
2752       break;
2753     case E_AVR_MACH_AVR4:
2754       strncat (buf, ", avr:4", size);
2755       break;
2756     case E_AVR_MACH_AVR5:
2757       strncat (buf, ", avr:5", size);
2758       break;
2759     case E_AVR_MACH_AVR51:
2760       strncat (buf, ", avr:51", size);
2761       break;
2762     case E_AVR_MACH_AVR6:
2763       strncat (buf, ", avr:6", size);
2764       break;
2765     case E_AVR_MACH_AVRTINY:
2766       strncat (buf, ", avr:100", size);
2767       break;
2768     case E_AVR_MACH_XMEGA1:
2769       strncat (buf, ", avr:101", size);
2770       break;
2771     case E_AVR_MACH_XMEGA2:
2772       strncat (buf, ", avr:102", size);
2773       break;
2774     case E_AVR_MACH_XMEGA3:
2775       strncat (buf, ", avr:103", size);
2776       break;
2777     case E_AVR_MACH_XMEGA4:
2778       strncat (buf, ", avr:104", size);
2779       break;
2780     case E_AVR_MACH_XMEGA5:
2781       strncat (buf, ", avr:105", size);
2782       break;
2783     case E_AVR_MACH_XMEGA6:
2784       strncat (buf, ", avr:106", size);
2785       break;
2786     case E_AVR_MACH_XMEGA7:
2787       strncat (buf, ", avr:107", size);
2788       break;
2789     default:
2790       strncat (buf, ", avr:<unknown>", size);
2791       break;
2792     }
2793
2794   size -= strlen (buf);
2795   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2796     strncat (buf, ", link-relax", size);
2797 }
2798
2799 static void
2800 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2801 {
2802   unsigned abi;
2803   unsigned arch;
2804   unsigned config;
2805   unsigned version;
2806   bfd_boolean has_fpu = FALSE;
2807   unsigned int r = 0;
2808
2809   static const char *ABI_STRINGS[] =
2810   {
2811     "ABI v0", /* use r5 as return register; only used in N1213HC */
2812     "ABI v1", /* use r0 as return register */
2813     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814     "ABI v2fp", /* for FPU */
2815     "AABI",
2816     "ABI2 FP+"
2817   };
2818   static const char *VER_STRINGS[] =
2819   {
2820     "Andes ELF V1.3 or older",
2821     "Andes ELF V1.3.1",
2822     "Andes ELF V1.4"
2823   };
2824   static const char *ARCH_STRINGS[] =
2825   {
2826     "",
2827     "Andes Star v1.0",
2828     "Andes Star v2.0",
2829     "Andes Star v3.0",
2830     "Andes Star v3.0m"
2831   };
2832
2833   abi = EF_NDS_ABI & e_flags;
2834   arch = EF_NDS_ARCH & e_flags;
2835   config = EF_NDS_INST & e_flags;
2836   version = EF_NDS32_ELF_VERSION & e_flags;
2837
2838   memset (buf, 0, size);
2839
2840   switch (abi)
2841     {
2842     case E_NDS_ABI_V0:
2843     case E_NDS_ABI_V1:
2844     case E_NDS_ABI_V2:
2845     case E_NDS_ABI_V2FP:
2846     case E_NDS_ABI_AABI:
2847     case E_NDS_ABI_V2FP_PLUS:
2848       /* In case there are holes in the array.  */
2849       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2850       break;
2851
2852     default:
2853       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2854       break;
2855     }
2856
2857   switch (version)
2858     {
2859     case E_NDS32_ELF_VER_1_2:
2860     case E_NDS32_ELF_VER_1_3:
2861     case E_NDS32_ELF_VER_1_4:
2862       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2863       break;
2864
2865     default:
2866       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2867       break;
2868     }
2869
2870   if (E_NDS_ABI_V0 == abi)
2871     {
2872       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2873       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874       if (arch == E_NDS_ARCH_STAR_V1_0)
2875         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2876       return;
2877     }
2878
2879   switch (arch)
2880     {
2881     case E_NDS_ARCH_STAR_V1_0:
2882     case E_NDS_ARCH_STAR_V2_0:
2883     case E_NDS_ARCH_STAR_V3_0:
2884     case E_NDS_ARCH_STAR_V3_M:
2885       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2886       break;
2887
2888     default:
2889       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2890       /* ARCH version determines how the e_flags are interpreted.
2891          If it is unknown, we cannot proceed.  */
2892       return;
2893     }
2894
2895   /* Newer ABI; Now handle architecture specific flags.  */
2896   if (arch == E_NDS_ARCH_STAR_V1_0)
2897     {
2898       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2899         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2900
2901       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2902         r += snprintf (buf + r, size -r, ", MAC");
2903
2904       if (config & E_NDS32_HAS_DIV_INST)
2905         r += snprintf (buf + r, size -r, ", DIV");
2906
2907       if (config & E_NDS32_HAS_16BIT_INST)
2908         r += snprintf (buf + r, size -r, ", 16b");
2909     }
2910   else
2911     {
2912       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2913         {
2914           if (version <= E_NDS32_ELF_VER_1_3)
2915             r += snprintf (buf + r, size -r, ", [B8]");
2916           else
2917             r += snprintf (buf + r, size -r, ", EX9");
2918         }
2919
2920       if (config & E_NDS32_HAS_MAC_DX_INST)
2921         r += snprintf (buf + r, size -r, ", MAC_DX");
2922
2923       if (config & E_NDS32_HAS_DIV_DX_INST)
2924         r += snprintf (buf + r, size -r, ", DIV_DX");
2925
2926       if (config & E_NDS32_HAS_16BIT_INST)
2927         {
2928           if (version <= E_NDS32_ELF_VER_1_3)
2929             r += snprintf (buf + r, size -r, ", 16b");
2930           else
2931             r += snprintf (buf + r, size -r, ", IFC");
2932         }
2933     }
2934
2935   if (config & E_NDS32_HAS_EXT_INST)
2936     r += snprintf (buf + r, size -r, ", PERF1");
2937
2938   if (config & E_NDS32_HAS_EXT2_INST)
2939     r += snprintf (buf + r, size -r, ", PERF2");
2940
2941   if (config & E_NDS32_HAS_FPU_INST)
2942     {
2943       has_fpu = TRUE;
2944       r += snprintf (buf + r, size -r, ", FPU_SP");
2945     }
2946
2947   if (config & E_NDS32_HAS_FPU_DP_INST)
2948     {
2949       has_fpu = TRUE;
2950       r += snprintf (buf + r, size -r, ", FPU_DP");
2951     }
2952
2953   if (config & E_NDS32_HAS_FPU_MAC_INST)
2954     {
2955       has_fpu = TRUE;
2956       r += snprintf (buf + r, size -r, ", FPU_MAC");
2957     }
2958
2959   if (has_fpu)
2960     {
2961       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2962         {
2963         case E_NDS32_FPU_REG_8SP_4DP:
2964           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2965           break;
2966         case E_NDS32_FPU_REG_16SP_8DP:
2967           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2968           break;
2969         case E_NDS32_FPU_REG_32SP_16DP:
2970           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2971           break;
2972         case E_NDS32_FPU_REG_32SP_32DP:
2973           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2974           break;
2975         }
2976     }
2977
2978   if (config & E_NDS32_HAS_AUDIO_INST)
2979     r += snprintf (buf + r, size -r, ", AUDIO");
2980
2981   if (config & E_NDS32_HAS_STRING_INST)
2982     r += snprintf (buf + r, size -r, ", STR");
2983
2984   if (config & E_NDS32_HAS_REDUCED_REGS)
2985     r += snprintf (buf + r, size -r, ", 16REG");
2986
2987   if (config & E_NDS32_HAS_VIDEO_INST)
2988     {
2989       if (version <= E_NDS32_ELF_VER_1_3)
2990         r += snprintf (buf + r, size -r, ", VIDEO");
2991       else
2992         r += snprintf (buf + r, size -r, ", SATURATION");
2993     }
2994
2995   if (config & E_NDS32_HAS_ENCRIPT_INST)
2996     r += snprintf (buf + r, size -r, ", ENCRP");
2997
2998   if (config & E_NDS32_HAS_L2C_INST)
2999     r += snprintf (buf + r, size -r, ", L2C");
3000 }
3001
3002 static char *
3003 get_machine_flags (unsigned e_flags, unsigned e_machine)
3004 {
3005   static char buf[1024];
3006
3007   buf[0] = '\0';
3008
3009   if (e_flags)
3010     {
3011       switch (e_machine)
3012         {
3013         default:
3014           break;
3015
3016         case EM_ARC_COMPACT2:
3017         case EM_ARC_COMPACT:
3018           decode_ARC_machine_flags (e_flags, e_machine, buf);
3019           break;
3020
3021         case EM_ARM:
3022           decode_ARM_machine_flags (e_flags, buf);
3023           break;
3024
3025         case EM_AVR:
3026           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3027           break;
3028
3029         case EM_BLACKFIN:
3030           if (e_flags & EF_BFIN_PIC)
3031             strcat (buf, ", PIC");
3032
3033           if (e_flags & EF_BFIN_FDPIC)
3034             strcat (buf, ", FDPIC");
3035
3036           if (e_flags & EF_BFIN_CODE_IN_L1)
3037             strcat (buf, ", code in L1");
3038
3039           if (e_flags & EF_BFIN_DATA_IN_L1)
3040             strcat (buf, ", data in L1");
3041
3042           break;
3043
3044         case EM_CYGNUS_FRV:
3045           switch (e_flags & EF_FRV_CPU_MASK)
3046             {
3047             case EF_FRV_CPU_GENERIC:
3048               break;
3049
3050             default:
3051               strcat (buf, ", fr???");
3052               break;
3053
3054             case EF_FRV_CPU_FR300:
3055               strcat (buf, ", fr300");
3056               break;
3057
3058             case EF_FRV_CPU_FR400:
3059               strcat (buf, ", fr400");
3060               break;
3061             case EF_FRV_CPU_FR405:
3062               strcat (buf, ", fr405");
3063               break;
3064
3065             case EF_FRV_CPU_FR450:
3066               strcat (buf, ", fr450");
3067               break;
3068
3069             case EF_FRV_CPU_FR500:
3070               strcat (buf, ", fr500");
3071               break;
3072             case EF_FRV_CPU_FR550:
3073               strcat (buf, ", fr550");
3074               break;
3075
3076             case EF_FRV_CPU_SIMPLE:
3077               strcat (buf, ", simple");
3078               break;
3079             case EF_FRV_CPU_TOMCAT:
3080               strcat (buf, ", tomcat");
3081               break;
3082             }
3083           break;
3084
3085         case EM_68K:
3086           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3087             strcat (buf, ", m68000");
3088           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3089             strcat (buf, ", cpu32");
3090           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3091             strcat (buf, ", fido_a");
3092           else
3093             {
3094               char const * isa = _("unknown");
3095               char const * mac = _("unknown mac");
3096               char const * additional = NULL;
3097
3098               switch (e_flags & EF_M68K_CF_ISA_MASK)
3099                 {
3100                 case EF_M68K_CF_ISA_A_NODIV:
3101                   isa = "A";
3102                   additional = ", nodiv";
3103                   break;
3104                 case EF_M68K_CF_ISA_A:
3105                   isa = "A";
3106                   break;
3107                 case EF_M68K_CF_ISA_A_PLUS:
3108                   isa = "A+";
3109                   break;
3110                 case EF_M68K_CF_ISA_B_NOUSP:
3111                   isa = "B";
3112                   additional = ", nousp";
3113                   break;
3114                 case EF_M68K_CF_ISA_B:
3115                   isa = "B";
3116                   break;
3117                 case EF_M68K_CF_ISA_C:
3118                   isa = "C";
3119                   break;
3120                 case EF_M68K_CF_ISA_C_NODIV:
3121                   isa = "C";
3122                   additional = ", nodiv";
3123                   break;
3124                 }
3125               strcat (buf, ", cf, isa ");
3126               strcat (buf, isa);
3127               if (additional)
3128                 strcat (buf, additional);
3129               if (e_flags & EF_M68K_CF_FLOAT)
3130                 strcat (buf, ", float");
3131               switch (e_flags & EF_M68K_CF_MAC_MASK)
3132                 {
3133                 case 0:
3134                   mac = NULL;
3135                   break;
3136                 case EF_M68K_CF_MAC:
3137                   mac = "mac";
3138                   break;
3139                 case EF_M68K_CF_EMAC:
3140                   mac = "emac";
3141                   break;
3142                 case EF_M68K_CF_EMAC_B:
3143                   mac = "emac_b";
3144                   break;
3145                 }
3146               if (mac)
3147                 {
3148                   strcat (buf, ", ");
3149                   strcat (buf, mac);
3150                 }
3151             }
3152           break;
3153
3154         case EM_CYGNUS_MEP:
3155           switch (e_flags & EF_MEP_CPU_MASK)
3156             {
3157             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3158             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3159             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3160             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3161             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3162             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3163             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3164             }
3165
3166           switch (e_flags & EF_MEP_COP_MASK)
3167             {
3168             case EF_MEP_COP_NONE: break;
3169             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3170             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3171             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3172             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3173             default: strcat (buf, _("<unknown MeP copro type>")); break;
3174             }
3175
3176           if (e_flags & EF_MEP_LIBRARY)
3177             strcat (buf, ", Built for Library");
3178
3179           if (e_flags & EF_MEP_INDEX_MASK)
3180             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3181                      e_flags & EF_MEP_INDEX_MASK);
3182
3183           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3184             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3185                      e_flags & ~ EF_MEP_ALL_FLAGS);
3186           break;
3187
3188         case EM_PPC:
3189           if (e_flags & EF_PPC_EMB)
3190             strcat (buf, ", emb");
3191
3192           if (e_flags & EF_PPC_RELOCATABLE)
3193             strcat (buf, _(", relocatable"));
3194
3195           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3196             strcat (buf, _(", relocatable-lib"));
3197           break;
3198
3199         case EM_PPC64:
3200           if (e_flags & EF_PPC64_ABI)
3201             {
3202               char abi[] = ", abiv0";
3203
3204               abi[6] += e_flags & EF_PPC64_ABI;
3205               strcat (buf, abi);
3206             }
3207           break;
3208
3209         case EM_V800:
3210           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3211             strcat (buf, ", RH850 ABI");
3212
3213           if (e_flags & EF_V800_850E3)
3214             strcat (buf, ", V3 architecture");
3215
3216           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3217             strcat (buf, ", FPU not used");
3218
3219           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3220             strcat (buf, ", regmode: COMMON");
3221
3222           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3223             strcat (buf, ", r4 not used");
3224
3225           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3226             strcat (buf, ", r30 not used");
3227
3228           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3229             strcat (buf, ", r5 not used");
3230
3231           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3232             strcat (buf, ", r2 not used");
3233
3234           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3235             {
3236               switch (e_flags & - e_flags)
3237                 {
3238                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3239                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3240                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3241                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3242                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3243                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3244                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3245                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3246                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3247                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3248                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3249                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3250                 default: break;
3251                 }
3252             }
3253           break;
3254
3255         case EM_V850:
3256         case EM_CYGNUS_V850:
3257           switch (e_flags & EF_V850_ARCH)
3258             {
3259             case E_V850E3V5_ARCH:
3260               strcat (buf, ", v850e3v5");
3261               break;
3262             case E_V850E2V3_ARCH:
3263               strcat (buf, ", v850e2v3");
3264               break;
3265             case E_V850E2_ARCH:
3266               strcat (buf, ", v850e2");
3267               break;
3268             case E_V850E1_ARCH:
3269               strcat (buf, ", v850e1");
3270               break;
3271             case E_V850E_ARCH:
3272               strcat (buf, ", v850e");
3273               break;
3274             case E_V850_ARCH:
3275               strcat (buf, ", v850");
3276               break;
3277             default:
3278               strcat (buf, _(", unknown v850 architecture variant"));
3279               break;
3280             }
3281           break;
3282
3283         case EM_M32R:
3284         case EM_CYGNUS_M32R:
3285           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3286             strcat (buf, ", m32r");
3287           break;
3288
3289         case EM_MIPS:
3290         case EM_MIPS_RS3_LE:
3291           if (e_flags & EF_MIPS_NOREORDER)
3292             strcat (buf, ", noreorder");
3293
3294           if (e_flags & EF_MIPS_PIC)
3295             strcat (buf, ", pic");
3296
3297           if (e_flags & EF_MIPS_CPIC)
3298             strcat (buf, ", cpic");
3299
3300           if (e_flags & EF_MIPS_UCODE)
3301             strcat (buf, ", ugen_reserved");
3302
3303           if (e_flags & EF_MIPS_ABI2)
3304             strcat (buf, ", abi2");
3305
3306           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3307             strcat (buf, ", odk first");
3308
3309           if (e_flags & EF_MIPS_32BITMODE)
3310             strcat (buf, ", 32bitmode");
3311
3312           if (e_flags & EF_MIPS_NAN2008)
3313             strcat (buf, ", nan2008");
3314
3315           if (e_flags & EF_MIPS_FP64)
3316             strcat (buf, ", fp64");
3317
3318           switch ((e_flags & EF_MIPS_MACH))
3319             {
3320             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3321             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3322             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3323             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3324             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3325             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3326             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3327             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3328             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3329             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3330             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3331             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3332             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3333             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3334             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3335             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3336             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3337             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3338             case 0:
3339             /* We simply ignore the field in this case to avoid confusion:
3340                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3341                extension.  */
3342               break;
3343             default: strcat (buf, _(", unknown CPU")); break;
3344             }
3345
3346           switch ((e_flags & EF_MIPS_ABI))
3347             {
3348             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3349             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3350             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3351             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3352             case 0:
3353             /* We simply ignore the field in this case to avoid confusion:
3354                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3355                This means it is likely to be an o32 file, but not for
3356                sure.  */
3357               break;
3358             default: strcat (buf, _(", unknown ABI")); break;
3359             }
3360
3361           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3362             strcat (buf, ", mdmx");
3363
3364           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3365             strcat (buf, ", mips16");
3366
3367           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3368             strcat (buf, ", micromips");
3369
3370           switch ((e_flags & EF_MIPS_ARCH))
3371             {
3372             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3373             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3374             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3375             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3376             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3377             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3378             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3379             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3380             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3381             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3382             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3383             default: strcat (buf, _(", unknown ISA")); break;
3384             }
3385           break;
3386
3387         case EM_NDS32:
3388           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3389           break;
3390
3391         case EM_RISCV:
3392           if (e_flags & EF_RISCV_RVC)
3393             strcat (buf, ", RVC");
3394
3395           switch (e_flags & EF_RISCV_FLOAT_ABI)
3396             {
3397             case EF_RISCV_FLOAT_ABI_SOFT:
3398               strcat (buf, ", soft-float ABI");
3399               break;
3400
3401             case EF_RISCV_FLOAT_ABI_SINGLE:
3402               strcat (buf, ", single-float ABI");
3403               break;
3404
3405             case EF_RISCV_FLOAT_ABI_DOUBLE:
3406               strcat (buf, ", double-float ABI");
3407               break;
3408
3409             case EF_RISCV_FLOAT_ABI_QUAD:
3410               strcat (buf, ", quad-float ABI");
3411               break;
3412             }
3413           break;
3414
3415         case EM_SH:
3416           switch ((e_flags & EF_SH_MACH_MASK))
3417             {
3418             case EF_SH1: strcat (buf, ", sh1"); break;
3419             case EF_SH2: strcat (buf, ", sh2"); break;
3420             case EF_SH3: strcat (buf, ", sh3"); break;
3421             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3422             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3423             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3424             case EF_SH3E: strcat (buf, ", sh3e"); break;
3425             case EF_SH4: strcat (buf, ", sh4"); break;
3426             case EF_SH5: strcat (buf, ", sh5"); break;
3427             case EF_SH2E: strcat (buf, ", sh2e"); break;
3428             case EF_SH4A: strcat (buf, ", sh4a"); break;
3429             case EF_SH2A: strcat (buf, ", sh2a"); break;
3430             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3431             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3432             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3433             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3434             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3435             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3436             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3437             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3438             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3439             default: strcat (buf, _(", unknown ISA")); break;
3440             }
3441
3442           if (e_flags & EF_SH_PIC)
3443             strcat (buf, ", pic");
3444
3445           if (e_flags & EF_SH_FDPIC)
3446             strcat (buf, ", fdpic");
3447           break;
3448
3449         case EM_OR1K:
3450           if (e_flags & EF_OR1K_NODELAY)
3451             strcat (buf, ", no delay");
3452           break;
3453
3454         case EM_SPARCV9:
3455           if (e_flags & EF_SPARC_32PLUS)
3456             strcat (buf, ", v8+");
3457
3458           if (e_flags & EF_SPARC_SUN_US1)
3459             strcat (buf, ", ultrasparcI");
3460
3461           if (e_flags & EF_SPARC_SUN_US3)
3462             strcat (buf, ", ultrasparcIII");
3463
3464           if (e_flags & EF_SPARC_HAL_R1)
3465             strcat (buf, ", halr1");
3466
3467           if (e_flags & EF_SPARC_LEDATA)
3468             strcat (buf, ", ledata");
3469
3470           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3471             strcat (buf, ", tso");
3472
3473           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3474             strcat (buf, ", pso");
3475
3476           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3477             strcat (buf, ", rmo");
3478           break;
3479
3480         case EM_PARISC:
3481           switch (e_flags & EF_PARISC_ARCH)
3482             {
3483             case EFA_PARISC_1_0:
3484               strcpy (buf, ", PA-RISC 1.0");
3485               break;
3486             case EFA_PARISC_1_1:
3487               strcpy (buf, ", PA-RISC 1.1");
3488               break;
3489             case EFA_PARISC_2_0:
3490               strcpy (buf, ", PA-RISC 2.0");
3491               break;
3492             default:
3493               break;
3494             }
3495           if (e_flags & EF_PARISC_TRAPNIL)
3496             strcat (buf, ", trapnil");
3497           if (e_flags & EF_PARISC_EXT)
3498             strcat (buf, ", ext");
3499           if (e_flags & EF_PARISC_LSB)
3500             strcat (buf, ", lsb");
3501           if (e_flags & EF_PARISC_WIDE)
3502             strcat (buf, ", wide");
3503           if (e_flags & EF_PARISC_NO_KABP)
3504             strcat (buf, ", no kabp");
3505           if (e_flags & EF_PARISC_LAZYSWAP)
3506             strcat (buf, ", lazyswap");
3507           break;
3508
3509         case EM_PJ:
3510         case EM_PJ_OLD:
3511           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3512             strcat (buf, ", new calling convention");
3513
3514           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3515             strcat (buf, ", gnu calling convention");
3516           break;
3517
3518         case EM_IA_64:
3519           if ((e_flags & EF_IA_64_ABI64))
3520             strcat (buf, ", 64-bit");
3521           else
3522             strcat (buf, ", 32-bit");
3523           if ((e_flags & EF_IA_64_REDUCEDFP))
3524             strcat (buf, ", reduced fp model");
3525           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3526             strcat (buf, ", no function descriptors, constant gp");
3527           else if ((e_flags & EF_IA_64_CONS_GP))
3528             strcat (buf, ", constant gp");
3529           if ((e_flags & EF_IA_64_ABSOLUTE))
3530             strcat (buf, ", absolute");
3531           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3532             {
3533               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3534                 strcat (buf, ", vms_linkages");
3535               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3536                 {
3537                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3538                   break;
3539                 case EF_IA_64_VMS_COMCOD_WARNING:
3540                   strcat (buf, ", warning");
3541                   break;
3542                 case EF_IA_64_VMS_COMCOD_ERROR:
3543                   strcat (buf, ", error");
3544                   break;
3545                 case EF_IA_64_VMS_COMCOD_ABORT:
3546                   strcat (buf, ", abort");
3547                   break;
3548                 default:
3549                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3550                         e_flags & EF_IA_64_VMS_COMCOD);
3551                   strcat (buf, ", <unknown>");
3552                 }
3553             }
3554           break;
3555
3556         case EM_VAX:
3557           if ((e_flags & EF_VAX_NONPIC))
3558             strcat (buf, ", non-PIC");
3559           if ((e_flags & EF_VAX_DFLOAT))
3560             strcat (buf, ", D-Float");
3561           if ((e_flags & EF_VAX_GFLOAT))
3562             strcat (buf, ", G-Float");
3563           break;
3564
3565         case EM_VISIUM:
3566           if (e_flags & EF_VISIUM_ARCH_MCM)
3567             strcat (buf, ", mcm");
3568           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3569             strcat (buf, ", mcm24");
3570           if (e_flags & EF_VISIUM_ARCH_GR6)
3571             strcat (buf, ", gr6");
3572           break;
3573
3574         case EM_RL78:
3575           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3576             {
3577             case E_FLAG_RL78_ANY_CPU: break;
3578             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3579             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3580             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3581             }
3582           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3583             strcat (buf, ", 64-bit doubles");
3584           break;
3585
3586         case EM_RX:
3587           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3588             strcat (buf, ", 64-bit doubles");
3589           if (e_flags & E_FLAG_RX_DSP)
3590             strcat (buf, ", dsp");
3591           if (e_flags & E_FLAG_RX_PID)
3592             strcat (buf, ", pid");
3593           if (e_flags & E_FLAG_RX_ABI)
3594             strcat (buf, ", RX ABI");
3595           if (e_flags & E_FLAG_RX_SINSNS_SET)
3596             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3597                     ? ", uses String instructions" : ", bans String instructions");
3598           if (e_flags & E_FLAG_RX_V2)
3599             strcat (buf, ", V2");
3600           break;
3601
3602         case EM_S390:
3603           if (e_flags & EF_S390_HIGH_GPRS)
3604             strcat (buf, ", highgprs");
3605           break;
3606
3607         case EM_TI_C6000:
3608           if ((e_flags & EF_C6000_REL))
3609             strcat (buf, ", relocatable module");
3610           break;
3611
3612         case EM_MSP430:
3613           strcat (buf, _(": architecture variant: "));
3614           switch (e_flags & EF_MSP430_MACH)
3615             {
3616             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3617             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3618             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3619             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3620             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3621             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3622             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3623             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3624             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3625             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3626             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3627             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3628             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3629             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3630             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3631             default:
3632               strcat (buf, _(": unknown")); break;
3633             }
3634
3635           if (e_flags & ~ EF_MSP430_MACH)
3636             strcat (buf, _(": unknown extra flag bits also present"));
3637         }
3638     }
3639
3640   return buf;
3641 }
3642
3643 static const char *
3644 get_osabi_name (unsigned int osabi)
3645 {
3646   static char buff[32];
3647
3648   switch (osabi)
3649     {
3650     case ELFOSABI_NONE:         return "UNIX - System V";
3651     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3652     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3653     case ELFOSABI_GNU:          return "UNIX - GNU";
3654     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3655     case ELFOSABI_AIX:          return "UNIX - AIX";
3656     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3657     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3658     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3659     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3660     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3661     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3662     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3663     case ELFOSABI_AROS:         return "AROS";
3664     case ELFOSABI_FENIXOS:      return "FenixOS";
3665     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3666     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3667     default:
3668       if (osabi >= 64)
3669         switch (elf_header.e_machine)
3670           {
3671           case EM_ARM:
3672             switch (osabi)
3673               {
3674               case ELFOSABI_ARM:        return "ARM";
3675               default:
3676                 break;
3677               }
3678             break;
3679
3680           case EM_MSP430:
3681           case EM_MSP430_OLD:
3682           case EM_VISIUM:
3683             switch (osabi)
3684               {
3685               case ELFOSABI_STANDALONE: return _("Standalone App");
3686               default:
3687                 break;
3688               }
3689             break;
3690
3691           case EM_TI_C6000:
3692             switch (osabi)
3693               {
3694               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3695               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3696               default:
3697                 break;
3698               }
3699             break;
3700
3701           default:
3702             break;
3703           }
3704       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3705       return buff;
3706     }
3707 }
3708
3709 static const char *
3710 get_aarch64_segment_type (unsigned long type)
3711 {
3712   switch (type)
3713     {
3714     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3715     default:                  return NULL;
3716     }
3717 }
3718
3719 static const char *
3720 get_arm_segment_type (unsigned long type)
3721 {
3722   switch (type)
3723     {
3724     case PT_ARM_EXIDX: return "EXIDX";
3725     default:           return NULL;
3726     }
3727 }
3728
3729 static const char *
3730 get_s390_segment_type (unsigned long type)
3731 {
3732   switch (type)
3733     {
3734     case PT_S390_PGSTE: return "S390_PGSTE";
3735     default:            return NULL;
3736     }
3737 }
3738
3739 static const char *
3740 get_mips_segment_type (unsigned long type)
3741 {
3742   switch (type)
3743     {
3744     case PT_MIPS_REGINFO:   return "REGINFO";
3745     case PT_MIPS_RTPROC:    return "RTPROC";
3746     case PT_MIPS_OPTIONS:   return "OPTIONS";
3747     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3748     default:                return NULL;
3749     }
3750 }
3751
3752 static const char *
3753 get_parisc_segment_type (unsigned long type)
3754 {
3755   switch (type)
3756     {
3757     case PT_HP_TLS:             return "HP_TLS";
3758     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3759     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3760     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3761     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3762     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3763     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3764     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3765     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3766     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3767     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3768     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3769     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3770     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3771     case PT_HP_STACK:           return "HP_STACK";
3772     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3773     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3774     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3775     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3776     default:                    return NULL;
3777     }
3778 }
3779
3780 static const char *
3781 get_ia64_segment_type (unsigned long type)
3782 {
3783   switch (type)
3784     {
3785     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3786     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3787     case PT_HP_TLS:             return "HP_TLS";
3788     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3789     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3790     case PT_IA_64_HP_STACK:     return "HP_STACK";
3791     default:                    return NULL;
3792     }
3793 }
3794
3795 static const char *
3796 get_tic6x_segment_type (unsigned long type)
3797 {
3798   switch (type)
3799     {
3800     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3801     default:               return NULL;
3802     }
3803 }
3804
3805 static const char *
3806 get_solaris_segment_type (unsigned long type)
3807 {
3808   switch (type)
3809     {
3810     case 0x6464e550: return "PT_SUNW_UNWIND";
3811     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3812     case 0x6ffffff7: return "PT_LOSUNW";
3813     case 0x6ffffffa: return "PT_SUNWBSS";
3814     case 0x6ffffffb: return "PT_SUNWSTACK";
3815     case 0x6ffffffc: return "PT_SUNWDTRACE";
3816     case 0x6ffffffd: return "PT_SUNWCAP";
3817     case 0x6fffffff: return "PT_HISUNW";
3818     default:         return NULL;
3819     }
3820 }
3821
3822 static const char *
3823 get_segment_type (unsigned long p_type)
3824 {
3825   static char buff[32];
3826
3827   switch (p_type)
3828     {
3829     case PT_NULL:       return "NULL";
3830     case PT_LOAD:       return "LOAD";
3831     case PT_DYNAMIC:    return "DYNAMIC";
3832     case PT_INTERP:     return "INTERP";
3833     case PT_NOTE:       return "NOTE";
3834     case PT_SHLIB:      return "SHLIB";
3835     case PT_PHDR:       return "PHDR";
3836     case PT_TLS:        return "TLS";
3837     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3838     case PT_GNU_STACK:  return "GNU_STACK";
3839     case PT_GNU_RELRO:  return "GNU_RELRO";
3840
3841     default:
3842       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3843         {
3844           sprintf (buff, "GNU_MBIND+%#lx",
3845                    p_type - PT_GNU_MBIND_LO);
3846         }
3847       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3848         {
3849           const char * result;
3850
3851           switch (elf_header.e_machine)
3852             {
3853             case EM_AARCH64:
3854               result = get_aarch64_segment_type (p_type);
3855               break;
3856             case EM_ARM:
3857               result = get_arm_segment_type (p_type);
3858               break;
3859             case EM_MIPS:
3860             case EM_MIPS_RS3_LE:
3861               result = get_mips_segment_type (p_type);
3862               break;
3863             case EM_PARISC:
3864               result = get_parisc_segment_type (p_type);
3865               break;
3866             case EM_IA_64:
3867               result = get_ia64_segment_type (p_type);
3868               break;
3869             case EM_TI_C6000:
3870               result = get_tic6x_segment_type (p_type);
3871               break;
3872             case EM_S390:
3873             case EM_S390_OLD:
3874               result = get_s390_segment_type (p_type);
3875               break;
3876             default:
3877               result = NULL;
3878               break;
3879             }
3880
3881           if (result != NULL)
3882             return result;
3883
3884           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3885         }
3886       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3887         {
3888           const char * result;
3889
3890           switch (elf_header.e_machine)
3891             {
3892             case EM_PARISC:
3893               result = get_parisc_segment_type (p_type);
3894               break;
3895             case EM_IA_64:
3896               result = get_ia64_segment_type (p_type);
3897               break;
3898             default:
3899               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3900                 result = get_solaris_segment_type (p_type);
3901               else
3902                 result = NULL;
3903               break;
3904             }
3905
3906           if (result != NULL)
3907             return result;
3908
3909           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3910         }
3911       else
3912         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3913
3914       return buff;
3915     }
3916 }
3917
3918 static const char *
3919 get_arc_section_type_name (unsigned int sh_type)
3920 {
3921   switch (sh_type)
3922     {
3923     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3924     default:
3925       break;
3926     }
3927   return NULL;
3928 }
3929
3930 static const char *
3931 get_mips_section_type_name (unsigned int sh_type)
3932 {
3933   switch (sh_type)
3934     {
3935     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3936     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3937     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3938     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3939     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3940     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3941     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3942     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3943     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3944     case SHT_MIPS_RELD:          return "MIPS_RELD";
3945     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3946     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3947     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3948     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3949     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3950     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3951     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3952     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3953     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3954     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3955     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3956     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3957     case SHT_MIPS_LINE:          return "MIPS_LINE";
3958     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3959     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3960     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3961     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3962     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3963     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3964     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3965     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3966     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3967     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3968     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3969     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3970     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3971     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3972     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3973     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3974     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3975     default:
3976       break;
3977     }
3978   return NULL;
3979 }
3980
3981 static const char *
3982 get_parisc_section_type_name (unsigned int sh_type)
3983 {
3984   switch (sh_type)
3985     {
3986     case SHT_PARISC_EXT:        return "PARISC_EXT";
3987     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
3988     case SHT_PARISC_DOC:        return "PARISC_DOC";
3989     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
3990     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
3991     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
3992     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
3993     default:                    return NULL;
3994     }
3995 }
3996
3997 static const char *
3998 get_ia64_section_type_name (unsigned int sh_type)
3999 {
4000   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4001   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4002     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
4003
4004   switch (sh_type)
4005     {
4006     case SHT_IA_64_EXT:                return "IA_64_EXT";
4007     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4008     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4009     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4010     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4011     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4012     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4013     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4014     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4015     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4016     default:
4017       break;
4018     }
4019   return NULL;
4020 }
4021
4022 static const char *
4023 get_x86_64_section_type_name (unsigned int sh_type)
4024 {
4025   switch (sh_type)
4026     {
4027     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4028     default:                    return NULL;
4029     }
4030 }
4031
4032 static const char *
4033 get_aarch64_section_type_name (unsigned int sh_type)
4034 {
4035   switch (sh_type)
4036     {
4037     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4038     default:                     return NULL;
4039     }
4040 }
4041
4042 static const char *
4043 get_arm_section_type_name (unsigned int sh_type)
4044 {
4045   switch (sh_type)
4046     {
4047     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4048     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4049     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4050     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4051     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4052     default:                      return NULL;
4053     }
4054 }
4055
4056 static const char *
4057 get_tic6x_section_type_name (unsigned int sh_type)
4058 {
4059   switch (sh_type)
4060     {
4061     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4062     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4063     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4064     case SHT_TI_ICODE:          return "TI_ICODE";
4065     case SHT_TI_XREF:           return "TI_XREF";
4066     case SHT_TI_HANDLER:        return "TI_HANDLER";
4067     case SHT_TI_INITINFO:       return "TI_INITINFO";
4068     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4069     default:                    return NULL;
4070     }
4071 }
4072
4073 static const char *
4074 get_msp430x_section_type_name (unsigned int sh_type)
4075 {
4076   switch (sh_type)
4077     {
4078     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4079     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4080     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4081     default:                      return NULL;
4082     }
4083 }
4084
4085 static const char *
4086 get_v850_section_type_name (unsigned int sh_type)
4087 {
4088   switch (sh_type)
4089     {
4090     case SHT_V850_SCOMMON:  return "V850 Small Common";
4091     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4092     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4093     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4094     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4095     default:                return NULL;
4096     }
4097 }
4098
4099 static const char *
4100 get_section_type_name (unsigned int sh_type)
4101 {
4102   static char buff[32];
4103   const char * result;
4104
4105   switch (sh_type)
4106     {
4107     case SHT_NULL:              return "NULL";
4108     case SHT_PROGBITS:          return "PROGBITS";
4109     case SHT_SYMTAB:            return "SYMTAB";
4110     case SHT_STRTAB:            return "STRTAB";
4111     case SHT_RELA:              return "RELA";
4112     case SHT_HASH:              return "HASH";
4113     case SHT_DYNAMIC:           return "DYNAMIC";
4114     case SHT_NOTE:              return "NOTE";
4115     case SHT_NOBITS:            return "NOBITS";
4116     case SHT_REL:               return "REL";
4117     case SHT_SHLIB:             return "SHLIB";
4118     case SHT_DYNSYM:            return "DYNSYM";
4119     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4120     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4121     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4122     case SHT_GNU_HASH:          return "GNU_HASH";
4123     case SHT_GROUP:             return "GROUP";
4124     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4125     case SHT_GNU_verdef:        return "VERDEF";
4126     case SHT_GNU_verneed:       return "VERNEED";
4127     case SHT_GNU_versym:        return "VERSYM";
4128     case 0x6ffffff0:            return "VERSYM";
4129     case 0x6ffffffc:            return "VERDEF";
4130     case 0x7ffffffd:            return "AUXILIARY";
4131     case 0x7fffffff:            return "FILTER";
4132     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4133
4134     default:
4135       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4136         {
4137           switch (elf_header.e_machine)
4138             {
4139             case EM_ARC:
4140             case EM_ARC_COMPACT:
4141             case EM_ARC_COMPACT2:
4142               result = get_arc_section_type_name (sh_type);
4143               break;
4144             case EM_MIPS:
4145             case EM_MIPS_RS3_LE:
4146               result = get_mips_section_type_name (sh_type);
4147               break;
4148             case EM_PARISC:
4149               result = get_parisc_section_type_name (sh_type);
4150               break;
4151             case EM_IA_64:
4152               result = get_ia64_section_type_name (sh_type);
4153               break;
4154             case EM_X86_64:
4155             case EM_L1OM:
4156             case EM_K1OM:
4157               result = get_x86_64_section_type_name (sh_type);
4158               break;
4159             case EM_AARCH64:
4160               result = get_aarch64_section_type_name (sh_type);
4161               break;
4162             case EM_ARM:
4163               result = get_arm_section_type_name (sh_type);
4164               break;
4165             case EM_TI_C6000:
4166               result = get_tic6x_section_type_name (sh_type);
4167               break;
4168             case EM_MSP430:
4169               result = get_msp430x_section_type_name (sh_type);
4170               break;
4171             case EM_V800:
4172             case EM_V850:
4173             case EM_CYGNUS_V850:
4174               result = get_v850_section_type_name (sh_type);
4175               break;
4176             default:
4177               result = NULL;
4178               break;
4179             }
4180
4181           if (result != NULL)
4182             return result;
4183
4184           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4185         }
4186       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4187         {
4188           switch (elf_header.e_machine)
4189             {
4190             case EM_IA_64:
4191               result = get_ia64_section_type_name (sh_type);
4192               break;
4193             default:
4194               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4195                 result = get_solaris_section_type (sh_type);
4196               else
4197                 {
4198                   switch (sh_type)
4199                     {
4200                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4201                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4202                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4203                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4204                     default:
4205                       result = NULL;
4206                       break;
4207                     }
4208                 }
4209               break;
4210             }
4211
4212           if (result != NULL)
4213             return result;
4214
4215           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4216         }
4217       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4218         {
4219           switch (elf_header.e_machine)
4220             {
4221             case EM_V800:
4222             case EM_V850:
4223             case EM_CYGNUS_V850:
4224               result = get_v850_section_type_name (sh_type);
4225               break;
4226             default:
4227               result = NULL;
4228               break;
4229             }
4230
4231           if (result != NULL)
4232             return result;
4233
4234           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4235         }
4236       else
4237         /* This message is probably going to be displayed in a 15
4238            character wide field, so put the hex value first.  */
4239         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4240
4241       return buff;
4242     }
4243 }
4244
4245 #define OPTION_DEBUG_DUMP       512
4246 #define OPTION_DYN_SYMS         513
4247 #define OPTION_DWARF_DEPTH      514
4248 #define OPTION_DWARF_START      515
4249 #define OPTION_DWARF_CHECK      516
4250
4251 static struct option options[] =
4252 {
4253   {"all",              no_argument, 0, 'a'},
4254   {"file-header",      no_argument, 0, 'h'},
4255   {"program-headers",  no_argument, 0, 'l'},
4256   {"headers",          no_argument, 0, 'e'},
4257   {"histogram",        no_argument, 0, 'I'},
4258   {"segments",         no_argument, 0, 'l'},
4259   {"sections",         no_argument, 0, 'S'},
4260   {"section-headers",  no_argument, 0, 'S'},
4261   {"section-groups",   no_argument, 0, 'g'},
4262   {"section-details",  no_argument, 0, 't'},
4263   {"full-section-name",no_argument, 0, 'N'},
4264   {"symbols",          no_argument, 0, 's'},
4265   {"syms",             no_argument, 0, 's'},
4266   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4267   {"relocs",           no_argument, 0, 'r'},
4268   {"notes",            no_argument, 0, 'n'},
4269   {"dynamic",          no_argument, 0, 'd'},
4270   {"arch-specific",    no_argument, 0, 'A'},
4271   {"version-info",     no_argument, 0, 'V'},
4272   {"use-dynamic",      no_argument, 0, 'D'},
4273   {"unwind",           no_argument, 0, 'u'},
4274   {"archive-index",    no_argument, 0, 'c'},
4275   {"hex-dump",         required_argument, 0, 'x'},
4276   {"relocated-dump",   required_argument, 0, 'R'},
4277   {"string-dump",      required_argument, 0, 'p'},
4278   {"decompress",       no_argument, 0, 'z'},
4279 #ifdef SUPPORT_DISASSEMBLY
4280   {"instruction-dump", required_argument, 0, 'i'},
4281 #endif
4282   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4283
4284   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4285   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4286   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4287
4288   {"version",          no_argument, 0, 'v'},
4289   {"wide",             no_argument, 0, 'W'},
4290   {"help",             no_argument, 0, 'H'},
4291   {0,                  no_argument, 0, 0}
4292 };
4293
4294 static void
4295 usage (FILE * stream)
4296 {
4297   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4298   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4299   fprintf (stream, _(" Options are:\n\
4300   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4301   -h --file-header       Display the ELF file header\n\
4302   -l --program-headers   Display the program headers\n\
4303      --segments          An alias for --program-headers\n\
4304   -S --section-headers   Display the sections' header\n\
4305      --sections          An alias for --section-headers\n\
4306   -g --section-groups    Display the section groups\n\
4307   -t --section-details   Display the section details\n\
4308   -e --headers           Equivalent to: -h -l -S\n\
4309   -s --syms              Display the symbol table\n\
4310      --symbols           An alias for --syms\n\
4311   --dyn-syms             Display the dynamic symbol table\n\
4312   -n --notes             Display the core notes (if present)\n\
4313   -r --relocs            Display the relocations (if present)\n\
4314   -u --unwind            Display the unwind info (if present)\n\
4315   -d --dynamic           Display the dynamic section (if present)\n\
4316   -V --version-info      Display the version sections (if present)\n\
4317   -A --arch-specific     Display architecture specific information (if any)\n\
4318   -c --archive-index     Display the symbol/file index in an archive\n\
4319   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4320   -x --hex-dump=<number|name>\n\
4321                          Dump the contents of section <number|name> as bytes\n\
4322   -p --string-dump=<number|name>\n\
4323                          Dump the contents of section <number|name> as strings\n\
4324   -R --relocated-dump=<number|name>\n\
4325                          Dump the contents of section <number|name> as relocated bytes\n\
4326   -z --decompress        Decompress section before dumping it\n\
4327   -w[lLiaprmfFsoRt] or\n\
4328   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4329                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4330                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4331                =addr,=cu_index]\n\
4332                          Display the contents of DWARF2 debug sections\n"));
4333   fprintf (stream, _("\
4334   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4335   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4336                          or deeper\n"));
4337 #ifdef SUPPORT_DISASSEMBLY
4338   fprintf (stream, _("\
4339   -i --instruction-dump=<number|name>\n\
4340                          Disassemble the contents of section <number|name>\n"));
4341 #endif
4342   fprintf (stream, _("\
4343   -I --histogram         Display histogram of bucket list lengths\n\
4344   -W --wide              Allow output width to exceed 80 characters\n\
4345   @<file>                Read options from <file>\n\
4346   -H --help              Display this information\n\
4347   -v --version           Display the version number of readelf\n"));
4348
4349   if (REPORT_BUGS_TO[0] && stream == stdout)
4350     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4351
4352   exit (stream == stdout ? 0 : 1);
4353 }
4354
4355 /* Record the fact that the user wants the contents of section number
4356    SECTION to be displayed using the method(s) encoded as flags bits
4357    in TYPE.  Note, TYPE can be zero if we are creating the array for
4358    the first time.  */
4359
4360 static void
4361 request_dump_bynumber (unsigned int section, dump_type type)
4362 {
4363   if (section >= num_dump_sects)
4364     {
4365       dump_type * new_dump_sects;
4366
4367       new_dump_sects = (dump_type *) calloc (section + 1,
4368                                              sizeof (* dump_sects));
4369
4370       if (new_dump_sects == NULL)
4371         error (_("Out of memory allocating dump request table.\n"));
4372       else
4373         {
4374           if (dump_sects)
4375             {
4376               /* Copy current flag settings.  */
4377               memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4378
4379               free (dump_sects);
4380             }
4381
4382           dump_sects = new_dump_sects;
4383           num_dump_sects = section + 1;
4384         }
4385     }
4386
4387   if (dump_sects)
4388     dump_sects[section] |= type;
4389
4390   return;
4391 }
4392
4393 /* Request a dump by section name.  */
4394
4395 static void
4396 request_dump_byname (const char * section, dump_type type)
4397 {
4398   struct dump_list_entry * new_request;
4399
4400   new_request = (struct dump_list_entry *)
4401       malloc (sizeof (struct dump_list_entry));
4402   if (!new_request)
4403     error (_("Out of memory allocating dump request table.\n"));
4404
4405   new_request->name = strdup (section);
4406   if (!new_request->name)
4407     error (_("Out of memory allocating dump request table.\n"));
4408
4409   new_request->type = type;
4410
4411   new_request->next = dump_sects_byname;
4412   dump_sects_byname = new_request;
4413 }
4414
4415 static inline void
4416 request_dump (dump_type type)
4417 {
4418   int section;
4419   char * cp;
4420
4421   do_dump++;
4422   section = strtoul (optarg, & cp, 0);
4423
4424   if (! *cp && section >= 0)
4425     request_dump_bynumber (section, type);
4426   else
4427     request_dump_byname (optarg, type);
4428 }
4429
4430
4431 static void
4432 parse_args (int argc, char ** argv)
4433 {
4434   int c;
4435
4436   if (argc < 2)
4437     usage (stderr);
4438
4439   while ((c = getopt_long
4440           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4441     {
4442       switch (c)
4443         {
4444         case 0:
4445           /* Long options.  */
4446           break;
4447         case 'H':
4448           usage (stdout);
4449           break;
4450
4451         case 'a':
4452           do_syms = TRUE;
4453           do_reloc = TRUE;
4454           do_unwind = TRUE;
4455           do_dynamic = TRUE;
4456           do_header = TRUE;
4457           do_sections = TRUE;
4458           do_section_groups = TRUE;
4459           do_segments = TRUE;
4460           do_version = TRUE;
4461           do_histogram = TRUE;
4462           do_arch = TRUE;
4463           do_notes = TRUE;
4464           break;
4465         case 'g':
4466           do_section_groups = TRUE;
4467           break;
4468         case 't':
4469         case 'N':
4470           do_sections = TRUE;
4471           do_section_details = TRUE;
4472           break;
4473         case 'e':
4474           do_header = TRUE;
4475           do_sections = TRUE;
4476           do_segments = TRUE;
4477           break;
4478         case 'A':
4479           do_arch = TRUE;
4480           break;
4481         case 'D':
4482           do_using_dynamic = TRUE;
4483           break;
4484         case 'r':
4485           do_reloc = TRUE;
4486           break;
4487         case 'u':
4488           do_unwind = TRUE;
4489           break;
4490         case 'h':
4491           do_header = TRUE;
4492           break;
4493         case 'l':
4494           do_segments = TRUE;
4495           break;
4496         case 's':
4497           do_syms = TRUE;
4498           break;
4499         case 'S':
4500           do_sections = TRUE;
4501           break;
4502         case 'd':
4503           do_dynamic = TRUE;
4504           break;
4505         case 'I':
4506           do_histogram = TRUE;
4507           break;
4508         case 'n':
4509           do_notes = TRUE;
4510           break;
4511         case 'c':
4512           do_archive_index = TRUE;
4513           break;
4514         case 'x':
4515           request_dump (HEX_DUMP);
4516           break;
4517         case 'p':
4518           request_dump (STRING_DUMP);
4519           break;
4520         case 'R':
4521           request_dump (RELOC_DUMP);
4522           break;
4523         case 'z':
4524           decompress_dumps = TRUE;
4525           break;
4526         case 'w':
4527           do_dump = TRUE;
4528           if (optarg == 0)
4529             {
4530               do_debugging = TRUE;
4531               dwarf_select_sections_all ();
4532             }
4533           else
4534             {
4535               do_debugging = FALSE;
4536               dwarf_select_sections_by_letters (optarg);
4537             }
4538           break;
4539         case OPTION_DEBUG_DUMP:
4540           do_dump = TRUE;
4541           if (optarg == 0)
4542             do_debugging = TRUE;
4543           else
4544             {
4545               do_debugging = FALSE;
4546               dwarf_select_sections_by_names (optarg);
4547             }
4548           break;
4549         case OPTION_DWARF_DEPTH:
4550           {
4551             char *cp;
4552
4553             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4554           }
4555           break;
4556         case OPTION_DWARF_START:
4557           {
4558             char *cp;
4559
4560             dwarf_start_die = strtoul (optarg, & cp, 0);
4561           }
4562           break;
4563         case OPTION_DWARF_CHECK:
4564           dwarf_check = TRUE;
4565           break;
4566         case OPTION_DYN_SYMS:
4567           do_dyn_syms = TRUE;
4568           break;
4569 #ifdef SUPPORT_DISASSEMBLY
4570         case 'i':
4571           request_dump (DISASS_DUMP);
4572           break;
4573 #endif
4574         case 'v':
4575           print_version (program_name);
4576           break;
4577         case 'V':
4578           do_version = TRUE;
4579           break;
4580         case 'W':
4581           do_wide = TRUE;
4582           break;
4583         default:
4584           /* xgettext:c-format */
4585           error (_("Invalid option '-%c'\n"), c);
4586           /* Fall through.  */
4587         case '?':
4588           usage (stderr);
4589         }
4590     }
4591
4592   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4593       && !do_segments && !do_header && !do_dump && !do_version
4594       && !do_histogram && !do_debugging && !do_arch && !do_notes
4595       && !do_section_groups && !do_archive_index
4596       && !do_dyn_syms)
4597     usage (stderr);
4598 }
4599
4600 static const char *
4601 get_elf_class (unsigned int elf_class)
4602 {
4603   static char buff[32];
4604
4605   switch (elf_class)
4606     {
4607     case ELFCLASSNONE: return _("none");
4608     case ELFCLASS32:   return "ELF32";
4609     case ELFCLASS64:   return "ELF64";
4610     default:
4611       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4612       return buff;
4613     }
4614 }
4615
4616 static const char *
4617 get_data_encoding (unsigned int encoding)
4618 {
4619   static char buff[32];
4620
4621   switch (encoding)
4622     {
4623     case ELFDATANONE: return _("none");
4624     case ELFDATA2LSB: return _("2's complement, little endian");
4625     case ELFDATA2MSB: return _("2's complement, big endian");
4626     default:
4627       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4628       return buff;
4629     }
4630 }
4631
4632 /* Decode the data held in 'elf_header'.  */
4633
4634 static bfd_boolean
4635 process_file_header (void)
4636 {
4637   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4638       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4639       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4640       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4641     {
4642       error
4643         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4644       return FALSE;
4645     }
4646
4647   init_dwarf_regnames (elf_header.e_machine);
4648
4649   if (do_header)
4650     {
4651       unsigned i;
4652
4653       printf (_("ELF Header:\n"));
4654       printf (_("  Magic:   "));
4655       for (i = 0; i < EI_NIDENT; i++)
4656         printf ("%2.2x ", elf_header.e_ident[i]);
4657       printf ("\n");
4658       printf (_("  Class:                             %s\n"),
4659               get_elf_class (elf_header.e_ident[EI_CLASS]));
4660       printf (_("  Data:                              %s\n"),
4661               get_data_encoding (elf_header.e_ident[EI_DATA]));
4662       printf (_("  Version:                           %d %s\n"),
4663               elf_header.e_ident[EI_VERSION],
4664               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4665                ? "(current)"
4666                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4667                   ? _("<unknown: %lx>")
4668                   : "")));
4669       printf (_("  OS/ABI:                            %s\n"),
4670               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4671       printf (_("  ABI Version:                       %d\n"),
4672               elf_header.e_ident[EI_ABIVERSION]);
4673       printf (_("  Type:                              %s\n"),
4674               get_file_type (elf_header.e_type));
4675       printf (_("  Machine:                           %s\n"),
4676               get_machine_name (elf_header.e_machine));
4677       printf (_("  Version:                           0x%lx\n"),
4678               (unsigned long) elf_header.e_version);
4679
4680       printf (_("  Entry point address:               "));
4681       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4682       printf (_("\n  Start of program headers:          "));
4683       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4684       printf (_(" (bytes into file)\n  Start of section headers:          "));
4685       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4686       printf (_(" (bytes into file)\n"));
4687
4688       printf (_("  Flags:                             0x%lx%s\n"),
4689               (unsigned long) elf_header.e_flags,
4690               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4691       printf (_("  Size of this header:               %ld (bytes)\n"),
4692               (long) elf_header.e_ehsize);
4693       printf (_("  Size of program headers:           %ld (bytes)\n"),
4694               (long) elf_header.e_phentsize);
4695       printf (_("  Number of program headers:         %ld"),
4696               (long) elf_header.e_phnum);
4697       if (section_headers != NULL
4698           && elf_header.e_phnum == PN_XNUM
4699           && section_headers[0].sh_info != 0)
4700         printf (" (%ld)", (long) section_headers[0].sh_info);
4701       putc ('\n', stdout);
4702       printf (_("  Size of section headers:           %ld (bytes)\n"),
4703               (long) elf_header.e_shentsize);
4704       printf (_("  Number of section headers:         %ld"),
4705               (long) elf_header.e_shnum);
4706       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4707         printf (" (%ld)", (long) section_headers[0].sh_size);
4708       putc ('\n', stdout);
4709       printf (_("  Section header string table index: %ld"),
4710               (long) elf_header.e_shstrndx);
4711       if (section_headers != NULL
4712           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4713         printf (" (%u)", section_headers[0].sh_link);
4714       else if (elf_header.e_shstrndx != SHN_UNDEF
4715                && elf_header.e_shstrndx >= elf_header.e_shnum)
4716         printf (_(" <corrupt: out of range>"));
4717       putc ('\n', stdout);
4718     }
4719
4720   if (section_headers != NULL)
4721     {
4722       if (elf_header.e_phnum == PN_XNUM
4723           && section_headers[0].sh_info != 0)
4724         elf_header.e_phnum = section_headers[0].sh_info;
4725       if (elf_header.e_shnum == SHN_UNDEF)
4726         elf_header.e_shnum = section_headers[0].sh_size;
4727       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4728         elf_header.e_shstrndx = section_headers[0].sh_link;
4729       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4730         elf_header.e_shstrndx = SHN_UNDEF;
4731       free (section_headers);
4732       section_headers = NULL;
4733     }
4734
4735   return TRUE;
4736 }
4737
4738 static bfd_boolean
4739 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4740 {
4741   Elf32_External_Phdr * phdrs;
4742   Elf32_External_Phdr * external;
4743   Elf_Internal_Phdr *   internal;
4744   unsigned int i;
4745   unsigned int size = elf_header.e_phentsize;
4746   unsigned int num  = elf_header.e_phnum;
4747
4748   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4749   if (size == 0 || num == 0)
4750     return FALSE;
4751   if (size < sizeof * phdrs)
4752     {
4753       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4754       return FALSE;
4755     }
4756   if (size > sizeof * phdrs)
4757     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4758
4759   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4760                                             size, num, _("program headers"));
4761   if (phdrs == NULL)
4762     return FALSE;
4763
4764   for (i = 0, internal = pheaders, external = phdrs;
4765        i < elf_header.e_phnum;
4766        i++, internal++, external++)
4767     {
4768       internal->p_type   = BYTE_GET (external->p_type);
4769       internal->p_offset = BYTE_GET (external->p_offset);
4770       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4771       internal->p_paddr  = BYTE_GET (external->p_paddr);
4772       internal->p_filesz = BYTE_GET (external->p_filesz);
4773       internal->p_memsz  = BYTE_GET (external->p_memsz);
4774       internal->p_flags  = BYTE_GET (external->p_flags);
4775       internal->p_align  = BYTE_GET (external->p_align);
4776     }
4777
4778   free (phdrs);
4779   return TRUE;
4780 }
4781
4782 static bfd_boolean
4783 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4784 {
4785   Elf64_External_Phdr * phdrs;
4786   Elf64_External_Phdr * external;
4787   Elf_Internal_Phdr *   internal;
4788   unsigned int i;
4789   unsigned int size = elf_header.e_phentsize;
4790   unsigned int num  = elf_header.e_phnum;
4791
4792   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4793   if (size == 0 || num == 0)
4794     return FALSE;
4795   if (size < sizeof * phdrs)
4796     {
4797       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4798       return FALSE;
4799     }
4800   if (size > sizeof * phdrs)
4801     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4802
4803   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4804                                             size, num, _("program headers"));
4805   if (!phdrs)
4806     return FALSE;
4807
4808   for (i = 0, internal = pheaders, external = phdrs;
4809        i < elf_header.e_phnum;
4810        i++, internal++, external++)
4811     {
4812       internal->p_type   = BYTE_GET (external->p_type);
4813       internal->p_flags  = BYTE_GET (external->p_flags);
4814       internal->p_offset = BYTE_GET (external->p_offset);
4815       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4816       internal->p_paddr  = BYTE_GET (external->p_paddr);
4817       internal->p_filesz = BYTE_GET (external->p_filesz);
4818       internal->p_memsz  = BYTE_GET (external->p_memsz);
4819       internal->p_align  = BYTE_GET (external->p_align);
4820     }
4821
4822   free (phdrs);
4823   return TRUE;
4824 }
4825
4826 /* Returns TRUE if the program headers were read into `program_headers'.  */
4827
4828 static bfd_boolean
4829 get_program_headers (FILE * file)
4830 {
4831   Elf_Internal_Phdr * phdrs;
4832
4833   /* Check cache of prior read.  */
4834   if (program_headers != NULL)
4835     return TRUE;
4836
4837   /* Be kind to memory checkers by looking for
4838      e_phnum values which we know must be invalid.  */
4839   if (elf_header.e_phnum
4840       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4841       >= current_file_size)
4842     {
4843       error (_("Too many program headers - %#x - the file is not that big\n"),
4844              elf_header.e_phnum);
4845       return FALSE;
4846     }
4847
4848   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4849                                          sizeof (Elf_Internal_Phdr));
4850   if (phdrs == NULL)
4851     {
4852       error (_("Out of memory reading %u program headers\n"),
4853              elf_header.e_phnum);
4854       return FALSE;
4855     }
4856
4857   if (is_32bit_elf
4858       ? get_32bit_program_headers (file, phdrs)
4859       : get_64bit_program_headers (file, phdrs))
4860     {
4861       program_headers = phdrs;
4862       return TRUE;
4863     }
4864
4865   free (phdrs);
4866   return FALSE;
4867 }
4868
4869 /* Returns TRUE if the program headers were loaded.  */
4870
4871 static bfd_boolean
4872 process_program_headers (FILE * file)
4873 {
4874   Elf_Internal_Phdr * segment;
4875   unsigned int i;
4876   Elf_Internal_Phdr * previous_load = NULL;
4877
4878   if (elf_header.e_phnum == 0)
4879     {
4880       /* PR binutils/12467.  */
4881       if (elf_header.e_phoff != 0)
4882         {
4883           warn (_("possibly corrupt ELF header - it has a non-zero program"
4884                   " header offset, but no program headers\n"));
4885           return FALSE;
4886         }
4887       else if (do_segments)
4888         printf (_("\nThere are no program headers in this file.\n"));
4889       return TRUE;
4890     }
4891
4892   if (do_segments && !do_header)
4893     {
4894       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4895       printf (_("Entry point "));
4896       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4897       printf (_("\nThere are %d program headers, starting at offset "),
4898               elf_header.e_phnum);
4899       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4900       printf ("\n");
4901     }
4902
4903   if (! get_program_headers (file))
4904     return TRUE;
4905
4906   if (do_segments)
4907     {
4908       if (elf_header.e_phnum > 1)
4909         printf (_("\nProgram Headers:\n"));
4910       else
4911         printf (_("\nProgram Headers:\n"));
4912
4913       if (is_32bit_elf)
4914         printf
4915           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4916       else if (do_wide)
4917         printf
4918           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4919       else
4920         {
4921           printf
4922             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4923           printf
4924             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4925         }
4926     }
4927
4928   dynamic_addr = 0;
4929   dynamic_size = 0;
4930
4931   for (i = 0, segment = program_headers;
4932        i < elf_header.e_phnum;
4933        i++, segment++)
4934     {
4935       if (do_segments)
4936         {
4937           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4938
4939           if (is_32bit_elf)
4940             {
4941               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4942               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4943               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4944               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4945               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4946               printf ("%c%c%c ",
4947                       (segment->p_flags & PF_R ? 'R' : ' '),
4948                       (segment->p_flags & PF_W ? 'W' : ' '),
4949                       (segment->p_flags & PF_X ? 'E' : ' '));
4950               printf ("%#lx", (unsigned long) segment->p_align);
4951             }
4952           else if (do_wide)
4953             {
4954               if ((unsigned long) segment->p_offset == segment->p_offset)
4955                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4956               else
4957                 {
4958                   print_vma (segment->p_offset, FULL_HEX);
4959                   putchar (' ');
4960                 }
4961
4962               print_vma (segment->p_vaddr, FULL_HEX);
4963               putchar (' ');
4964               print_vma (segment->p_paddr, FULL_HEX);
4965               putchar (' ');
4966
4967               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4968                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4969               else
4970                 {
4971                   print_vma (segment->p_filesz, FULL_HEX);
4972                   putchar (' ');
4973                 }
4974
4975               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4976                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4977               else
4978                 {
4979                   print_vma (segment->p_memsz, FULL_HEX);
4980                 }
4981
4982               printf (" %c%c%c ",
4983                       (segment->p_flags & PF_R ? 'R' : ' '),
4984                       (segment->p_flags & PF_W ? 'W' : ' '),
4985                       (segment->p_flags & PF_X ? 'E' : ' '));
4986
4987               if ((unsigned long) segment->p_align == segment->p_align)
4988                 printf ("%#lx", (unsigned long) segment->p_align);
4989               else
4990                 {
4991                   print_vma (segment->p_align, PREFIX_HEX);
4992                 }
4993             }
4994           else
4995             {
4996               print_vma (segment->p_offset, FULL_HEX);
4997               putchar (' ');
4998               print_vma (segment->p_vaddr, FULL_HEX);
4999               putchar (' ');
5000               print_vma (segment->p_paddr, FULL_HEX);
5001               printf ("\n                 ");
5002               print_vma (segment->p_filesz, FULL_HEX);
5003               putchar (' ');
5004               print_vma (segment->p_memsz, FULL_HEX);
5005               printf ("  %c%c%c    ",
5006                       (segment->p_flags & PF_R ? 'R' : ' '),
5007                       (segment->p_flags & PF_W ? 'W' : ' '),
5008                       (segment->p_flags & PF_X ? 'E' : ' '));
5009               print_vma (segment->p_align, PREFIX_HEX);
5010             }
5011
5012           putc ('\n', stdout);
5013         }
5014
5015       switch (segment->p_type)
5016         {
5017         case PT_LOAD:
5018 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5019          required by the ELF standard, several programs, including the Linux
5020          kernel, make use of non-ordered segments.  */
5021           if (previous_load
5022               && previous_load->p_vaddr > segment->p_vaddr)
5023             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5024 #endif
5025           if (segment->p_memsz < segment->p_filesz)
5026             error (_("the segment's file size is larger than its memory size\n"));
5027           previous_load = segment;
5028           break;
5029
5030         case PT_PHDR:
5031           /* PR 20815 - Verify that the program header is loaded into memory.  */
5032           if (i > 0 && previous_load != NULL)
5033             error (_("the PHDR segment must occur before any LOAD segment\n"));
5034           if (elf_header.e_machine != EM_PARISC)
5035             {
5036               unsigned int j;
5037
5038               for (j = 1; j < elf_header.e_phnum; j++)
5039                 if (program_headers[j].p_vaddr <= segment->p_vaddr
5040                     && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5041                     >= (segment->p_vaddr + segment->p_filesz))
5042                   break;
5043               if (j == elf_header.e_phnum)
5044                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5045             }
5046           break;
5047
5048         case PT_DYNAMIC:
5049           if (dynamic_addr)
5050             error (_("more than one dynamic segment\n"));
5051
5052           /* By default, assume that the .dynamic section is the first
5053              section in the DYNAMIC segment.  */
5054           dynamic_addr = segment->p_offset;
5055           dynamic_size = segment->p_filesz;
5056
5057           /* Try to locate the .dynamic section. If there is
5058              a section header table, we can easily locate it.  */
5059           if (section_headers != NULL)
5060             {
5061               Elf_Internal_Shdr * sec;
5062
5063               sec = find_section (".dynamic");
5064               if (sec == NULL || sec->sh_size == 0)
5065                 {
5066                   /* A corresponding .dynamic section is expected, but on
5067                      IA-64/OpenVMS it is OK for it to be missing.  */
5068                   if (!is_ia64_vms ())
5069                     error (_("no .dynamic section in the dynamic segment\n"));
5070                   break;
5071                 }
5072
5073               if (sec->sh_type == SHT_NOBITS)
5074                 {
5075                   dynamic_size = 0;
5076                   break;
5077                 }
5078
5079               dynamic_addr = sec->sh_offset;
5080               dynamic_size = sec->sh_size;
5081
5082               if (dynamic_addr < segment->p_offset
5083                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5084                 warn (_("the .dynamic section is not contained"
5085                         " within the dynamic segment\n"));
5086               else if (dynamic_addr > segment->p_offset)
5087                 warn (_("the .dynamic section is not the first section"
5088                         " in the dynamic segment.\n"));
5089             }
5090
5091           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5092              segment.  Check this after matching against the section headers
5093              so we don't warn on debuginfo file (which have NOBITS .dynamic
5094              sections).  */
5095           if (dynamic_addr + dynamic_size >= current_file_size)
5096             {
5097               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5098               dynamic_addr = dynamic_size = 0;
5099             }
5100           break;
5101
5102         case PT_INTERP:
5103           if (fseek (file, archive_file_offset + (long) segment->p_offset,
5104                      SEEK_SET))
5105             error (_("Unable to find program interpreter name\n"));
5106           else
5107             {
5108               char fmt [32];
5109               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5110
5111               if (ret >= (int) sizeof (fmt) || ret < 0)
5112                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5113
5114               program_interpreter[0] = 0;
5115               if (fscanf (file, fmt, program_interpreter) <= 0)
5116                 error (_("Unable to read program interpreter name\n"));
5117
5118               if (do_segments)
5119                 printf (_("      [Requesting program interpreter: %s]\n"),
5120                     program_interpreter);
5121             }
5122           break;
5123         }
5124     }
5125
5126   if (do_segments && section_headers != NULL && string_table != NULL)
5127     {
5128       printf (_("\n Section to Segment mapping:\n"));
5129       printf (_("  Segment Sections...\n"));
5130
5131       for (i = 0; i < elf_header.e_phnum; i++)
5132         {
5133           unsigned int j;
5134           Elf_Internal_Shdr * section;
5135
5136           segment = program_headers + i;
5137           section = section_headers + 1;
5138
5139           printf ("   %2.2d     ", i);
5140
5141           for (j = 1; j < elf_header.e_shnum; j++, section++)
5142             {
5143               if (!ELF_TBSS_SPECIAL (section, segment)
5144                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5145                 printf ("%s ", printable_section_name (section));
5146             }
5147
5148           putc ('\n',stdout);
5149         }
5150     }
5151
5152   return TRUE;
5153 }
5154
5155
5156 /* Find the file offset corresponding to VMA by using the program headers.  */
5157
5158 static long
5159 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5160 {
5161   Elf_Internal_Phdr * seg;
5162
5163   if (! get_program_headers (file))
5164     {
5165       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5166       return (long) vma;
5167     }
5168
5169   for (seg = program_headers;
5170        seg < program_headers + elf_header.e_phnum;
5171        ++seg)
5172     {
5173       if (seg->p_type != PT_LOAD)
5174         continue;
5175
5176       if (vma >= (seg->p_vaddr & -seg->p_align)
5177           && vma + size <= seg->p_vaddr + seg->p_filesz)
5178         return vma - seg->p_vaddr + seg->p_offset;
5179     }
5180
5181   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5182         (unsigned long) vma);
5183   return (long) vma;
5184 }
5185
5186
5187 /* Allocate memory and load the sections headers into the global pointer
5188    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
5189    generate any error messages if the load fails.  */
5190
5191 static bfd_boolean
5192 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5193 {
5194   Elf32_External_Shdr * shdrs;
5195   Elf_Internal_Shdr *   internal;
5196   unsigned int i;
5197   unsigned int size = elf_header.e_shentsize;
5198   unsigned int num = probe ? 1 : elf_header.e_shnum;
5199
5200   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5201   if (size == 0 || num == 0)
5202     return FALSE;
5203   if (size < sizeof * shdrs)
5204     {
5205       if (! probe)
5206         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5207       return FALSE;
5208     }
5209   if (!probe && size > sizeof * shdrs)
5210     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5211
5212   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5213                                             size, num,
5214                                             probe ? NULL : _("section headers"));
5215   if (shdrs == NULL)
5216     return FALSE;
5217
5218   if (section_headers != NULL)
5219     free (section_headers);
5220   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5221                                                    sizeof (Elf_Internal_Shdr));
5222   if (section_headers == NULL)
5223     {
5224       if (!probe)
5225         error (_("Out of memory reading %u section headers\n"), num);
5226       return FALSE;
5227     }
5228
5229   for (i = 0, internal = section_headers;
5230        i < num;
5231        i++, internal++)
5232     {
5233       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5234       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5235       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5236       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5237       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5238       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5239       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5240       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5241       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5242       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5243       if (!probe && internal->sh_link > num)
5244         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5245       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5246         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5247     }
5248
5249   free (shdrs);
5250   return TRUE;
5251 }
5252
5253 static bfd_boolean
5254 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5255 {
5256   Elf64_External_Shdr * shdrs;
5257   Elf_Internal_Shdr *   internal;
5258   unsigned int i;
5259   unsigned int size = elf_header.e_shentsize;
5260   unsigned int num = probe ? 1 : elf_header.e_shnum;
5261
5262   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5263   if (size == 0 || num == 0)
5264     return FALSE;
5265   if (size < sizeof * shdrs)
5266     {
5267       if (! probe)
5268         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5269       return FALSE;
5270     }
5271   if (! probe && size > sizeof * shdrs)
5272     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5273
5274   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5275                                             size, num,
5276                                             probe ? NULL : _("section headers"));
5277   if (shdrs == NULL)
5278     return FALSE;
5279
5280   if (section_headers != NULL)
5281     free (section_headers);
5282   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5283                                                    sizeof (Elf_Internal_Shdr));
5284   if (section_headers == NULL)
5285     {
5286       if (! probe)
5287         error (_("Out of memory reading %u section headers\n"), num);
5288       return FALSE;
5289     }
5290
5291   for (i = 0, internal = section_headers;
5292        i < num;
5293        i++, internal++)
5294     {
5295       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5296       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5297       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5298       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5299       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5300       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5301       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5302       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5303       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5304       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5305       if (!probe && internal->sh_link > num)
5306         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5307       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5308         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5309     }
5310
5311   free (shdrs);
5312   return TRUE;
5313 }
5314
5315 static Elf_Internal_Sym *
5316 get_32bit_elf_symbols (FILE * file,
5317                        Elf_Internal_Shdr * section,
5318                        unsigned long * num_syms_return)
5319 {
5320   unsigned long number = 0;
5321   Elf32_External_Sym * esyms = NULL;
5322   Elf_External_Sym_Shndx * shndx = NULL;
5323   Elf_Internal_Sym * isyms = NULL;
5324   Elf_Internal_Sym * psym;
5325   unsigned int j;
5326
5327   if (section->sh_size == 0)
5328     {
5329       if (num_syms_return != NULL)
5330         * num_syms_return = 0;
5331       return NULL;
5332     }
5333
5334   /* Run some sanity checks first.  */
5335   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5336     {
5337       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5338              printable_section_name (section), (unsigned long) section->sh_entsize);
5339       goto exit_point;
5340     }
5341
5342   if (section->sh_size > current_file_size)
5343     {
5344       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5345              printable_section_name (section), (unsigned long) section->sh_size);
5346       goto exit_point;
5347     }
5348
5349   number = section->sh_size / section->sh_entsize;
5350
5351   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5352     {
5353       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5354              (unsigned long) section->sh_size,
5355              printable_section_name (section),
5356              (unsigned long) section->sh_entsize);
5357       goto exit_point;
5358     }
5359
5360   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5361                                            section->sh_size, _("symbols"));
5362   if (esyms == NULL)
5363     goto exit_point;
5364
5365   {
5366     elf_section_list * entry;
5367
5368     shndx = NULL;
5369     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5370       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5371         {
5372           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5373                                                        entry->hdr->sh_offset,
5374                                                        1, entry->hdr->sh_size,
5375                                                        _("symbol table section indicies"));
5376           if (shndx == NULL)
5377             goto exit_point;
5378           /* PR17531: file: heap-buffer-overflow */
5379           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5380             {
5381               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5382                      printable_section_name (entry->hdr),
5383                      (unsigned long) entry->hdr->sh_size,
5384                      (unsigned long) section->sh_size);
5385               goto exit_point;
5386             }
5387         }
5388   }
5389
5390   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5391
5392   if (isyms == NULL)
5393     {
5394       error (_("Out of memory reading %lu symbols\n"),
5395              (unsigned long) number);
5396       goto exit_point;
5397     }
5398
5399   for (j = 0, psym = isyms; j < number; j++, psym++)
5400     {
5401       psym->st_name  = BYTE_GET (esyms[j].st_name);
5402       psym->st_value = BYTE_GET (esyms[j].st_value);
5403       psym->st_size  = BYTE_GET (esyms[j].st_size);
5404       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5405       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5406         psym->st_shndx
5407           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5408       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5409         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5410       psym->st_info  = BYTE_GET (esyms[j].st_info);
5411       psym->st_other = BYTE_GET (esyms[j].st_other);
5412     }
5413
5414  exit_point:
5415   if (shndx != NULL)
5416     free (shndx);
5417   if (esyms != NULL)
5418     free (esyms);
5419
5420   if (num_syms_return != NULL)
5421     * num_syms_return = isyms == NULL ? 0 : number;
5422
5423   return isyms;
5424 }
5425
5426 static Elf_Internal_Sym *
5427 get_64bit_elf_symbols (FILE * file,
5428                        Elf_Internal_Shdr * section,
5429                        unsigned long * num_syms_return)
5430 {
5431   unsigned long number = 0;
5432   Elf64_External_Sym * esyms = NULL;
5433   Elf_External_Sym_Shndx * shndx = NULL;
5434   Elf_Internal_Sym * isyms = NULL;
5435   Elf_Internal_Sym * psym;
5436   unsigned int j;
5437
5438   if (section->sh_size == 0)
5439     {
5440       if (num_syms_return != NULL)
5441         * num_syms_return = 0;
5442       return NULL;
5443     }
5444
5445   /* Run some sanity checks first.  */
5446   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5447     {
5448       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449              printable_section_name (section),
5450              (unsigned long) section->sh_entsize);
5451       goto exit_point;
5452     }
5453
5454   if (section->sh_size > current_file_size)
5455     {
5456       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457              printable_section_name (section),
5458              (unsigned long) section->sh_size);
5459       goto exit_point;
5460     }
5461
5462   number = section->sh_size / section->sh_entsize;
5463
5464   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5465     {
5466       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467              (unsigned long) section->sh_size,
5468              printable_section_name (section),
5469              (unsigned long) section->sh_entsize);
5470       goto exit_point;
5471     }
5472
5473   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5474                                            section->sh_size, _("symbols"));
5475   if (!esyms)
5476     goto exit_point;
5477
5478   {
5479     elf_section_list * entry;
5480
5481     shndx = NULL;
5482     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5483       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5484         {
5485           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5486                                                        entry->hdr->sh_offset,
5487                                                        1, entry->hdr->sh_size,
5488                                                        _("symbol table section indicies"));
5489           if (shndx == NULL)
5490             goto exit_point;
5491           /* PR17531: file: heap-buffer-overflow */
5492           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5493             {
5494               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495                      printable_section_name (entry->hdr),
5496                      (unsigned long) entry->hdr->sh_size,
5497                      (unsigned long) section->sh_size);
5498               goto exit_point;
5499             }
5500         }
5501   }
5502
5503   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5504
5505   if (isyms == NULL)
5506     {
5507       error (_("Out of memory reading %lu symbols\n"),
5508              (unsigned long) number);
5509       goto exit_point;
5510     }
5511
5512   for (j = 0, psym = isyms; j < number; j++, psym++)
5513     {
5514       psym->st_name  = BYTE_GET (esyms[j].st_name);
5515       psym->st_info  = BYTE_GET (esyms[j].st_info);
5516       psym->st_other = BYTE_GET (esyms[j].st_other);
5517       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5518
5519       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5520         psym->st_shndx
5521           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5522       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5523         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5524
5525       psym->st_value = BYTE_GET (esyms[j].st_value);
5526       psym->st_size  = BYTE_GET (esyms[j].st_size);
5527     }
5528
5529  exit_point:
5530   if (shndx != NULL)
5531     free (shndx);
5532   if (esyms != NULL)
5533     free (esyms);
5534
5535   if (num_syms_return != NULL)
5536     * num_syms_return = isyms == NULL ? 0 : number;
5537
5538   return isyms;
5539 }
5540
5541 static const char *
5542 get_elf_section_flags (bfd_vma sh_flags)
5543 {
5544   static char buff[1024];
5545   char * p = buff;
5546   unsigned int field_size = is_32bit_elf ? 8 : 16;
5547   signed int sindex;
5548   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5549   bfd_vma os_flags = 0;
5550   bfd_vma proc_flags = 0;
5551   bfd_vma unknown_flags = 0;
5552   static const struct
5553     {
5554       const char * str;
5555       unsigned int len;
5556     }
5557   flags [] =
5558     {
5559       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5560       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5561       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5562       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5563       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5564       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5565       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5566       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5567       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5568       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5569       /* IA-64 specific.  */
5570       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5571       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5572       /* IA-64 OpenVMS specific.  */
5573       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5574       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5575       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5576       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5577       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5578       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5579       /* Generic.  */
5580       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5581       /* SPARC specific.  */
5582       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5583       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5584       /* ARM specific.  */
5585       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5586       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5587       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5588       /* GNU specific.  */
5589       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5590       /* VLE specific.  */
5591       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5592     };
5593
5594   if (do_section_details)
5595     {
5596       sprintf (buff, "[%*.*lx]: ",
5597                field_size, field_size, (unsigned long) sh_flags);
5598       p += field_size + 4;
5599     }
5600
5601   while (sh_flags)
5602     {
5603       bfd_vma flag;
5604
5605       flag = sh_flags & - sh_flags;
5606       sh_flags &= ~ flag;
5607
5608       if (do_section_details)
5609         {
5610           switch (flag)
5611             {
5612             case SHF_WRITE:             sindex = 0; break;
5613             case SHF_ALLOC:             sindex = 1; break;
5614             case SHF_EXECINSTR:         sindex = 2; break;
5615             case SHF_MERGE:             sindex = 3; break;
5616             case SHF_STRINGS:           sindex = 4; break;
5617             case SHF_INFO_LINK:         sindex = 5; break;
5618             case SHF_LINK_ORDER:        sindex = 6; break;
5619             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5620             case SHF_GROUP:             sindex = 8; break;
5621             case SHF_TLS:               sindex = 9; break;
5622             case SHF_EXCLUDE:           sindex = 18; break;
5623             case SHF_COMPRESSED:        sindex = 20; break;
5624             case SHF_GNU_MBIND:         sindex = 24; break;
5625
5626             default:
5627               sindex = -1;
5628               switch (elf_header.e_machine)
5629                 {
5630                 case EM_IA_64:
5631                   if (flag == SHF_IA_64_SHORT)
5632                     sindex = 10;
5633                   else if (flag == SHF_IA_64_NORECOV)
5634                     sindex = 11;
5635 #ifdef BFD64
5636                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5637                     switch (flag)
5638                       {
5639                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5640                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5641                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5642                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5643                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5644                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5645                       default:                        break;
5646                       }
5647 #endif
5648                   break;
5649
5650                 case EM_386:
5651                 case EM_IAMCU:
5652                 case EM_X86_64:
5653                 case EM_L1OM:
5654                 case EM_K1OM:
5655                 case EM_OLD_SPARCV9:
5656                 case EM_SPARC32PLUS:
5657                 case EM_SPARCV9:
5658                 case EM_SPARC:
5659                   if (flag == SHF_ORDERED)
5660                     sindex = 19;
5661                   break;
5662
5663                 case EM_ARM:
5664                   switch (flag)
5665                     {
5666                     case SHF_ENTRYSECT: sindex = 21; break;
5667                     case SHF_ARM_PURECODE: sindex = 22; break;
5668                     case SHF_COMDEF: sindex = 23; break;
5669                     default: break;
5670                     }
5671                   break;
5672                 case EM_PPC:
5673                   if (flag == SHF_PPC_VLE)
5674                     sindex = 25;
5675                   break;
5676
5677                 default:
5678                   break;
5679                 }
5680             }
5681
5682           if (sindex != -1)
5683             {
5684               if (p != buff + field_size + 4)
5685                 {
5686                   if (size < (10 + 2))
5687                     {
5688                       warn (_("Internal error: not enough buffer room for section flag info"));
5689                       return _("<unknown>");
5690                     }
5691                   size -= 2;
5692                   *p++ = ',';
5693                   *p++ = ' ';
5694                 }
5695
5696               size -= flags [sindex].len;
5697               p = stpcpy (p, flags [sindex].str);
5698             }
5699           else if (flag & SHF_MASKOS)
5700             os_flags |= flag;
5701           else if (flag & SHF_MASKPROC)
5702             proc_flags |= flag;
5703           else
5704             unknown_flags |= flag;
5705         }
5706       else
5707         {
5708           switch (flag)
5709             {
5710             case SHF_WRITE:             *p = 'W'; break;
5711             case SHF_ALLOC:             *p = 'A'; break;
5712             case SHF_EXECINSTR:         *p = 'X'; break;
5713             case SHF_MERGE:             *p = 'M'; break;
5714             case SHF_STRINGS:           *p = 'S'; break;
5715             case SHF_INFO_LINK:         *p = 'I'; break;
5716             case SHF_LINK_ORDER:        *p = 'L'; break;
5717             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5718             case SHF_GROUP:             *p = 'G'; break;
5719             case SHF_TLS:               *p = 'T'; break;
5720             case SHF_EXCLUDE:           *p = 'E'; break;
5721             case SHF_COMPRESSED:        *p = 'C'; break;
5722             case SHF_GNU_MBIND:         *p = 'D'; break;
5723
5724             default:
5725               if ((elf_header.e_machine == EM_X86_64
5726                    || elf_header.e_machine == EM_L1OM
5727                    || elf_header.e_machine == EM_K1OM)
5728                   && flag == SHF_X86_64_LARGE)
5729                 *p = 'l';
5730               else if (elf_header.e_machine == EM_ARM
5731                        && flag == SHF_ARM_PURECODE)
5732                   *p = 'y';
5733               else if (elf_header.e_machine == EM_PPC
5734                        && flag == SHF_PPC_VLE)
5735                   *p = 'v';
5736               else if (flag & SHF_MASKOS)
5737                 {
5738                   *p = 'o';
5739                   sh_flags &= ~ SHF_MASKOS;
5740                 }
5741               else if (flag & SHF_MASKPROC)
5742                 {
5743                   *p = 'p';
5744                   sh_flags &= ~ SHF_MASKPROC;
5745                 }
5746               else
5747                 *p = 'x';
5748               break;
5749             }
5750           p++;
5751         }
5752     }
5753
5754   if (do_section_details)
5755     {
5756       if (os_flags)
5757         {
5758           size -= 5 + field_size;
5759           if (p != buff + field_size + 4)
5760             {
5761               if (size < (2 + 1))
5762                 {
5763                   warn (_("Internal error: not enough buffer room for section flag info"));
5764                   return _("<unknown>");
5765                 }
5766               size -= 2;
5767               *p++ = ',';
5768               *p++ = ' ';
5769             }
5770           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5771                    (unsigned long) os_flags);
5772           p += 5 + field_size;
5773         }
5774       if (proc_flags)
5775         {
5776           size -= 7 + field_size;
5777           if (p != buff + field_size + 4)
5778             {
5779               if (size < (2 + 1))
5780                 {
5781                   warn (_("Internal error: not enough buffer room for section flag info"));
5782                   return _("<unknown>");
5783                 }
5784               size -= 2;
5785               *p++ = ',';
5786               *p++ = ' ';
5787             }
5788           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5789                    (unsigned long) proc_flags);
5790           p += 7 + field_size;
5791         }
5792       if (unknown_flags)
5793         {
5794           size -= 10 + field_size;
5795           if (p != buff + field_size + 4)
5796             {
5797               if (size < (2 + 1))
5798                 {
5799                   warn (_("Internal error: not enough buffer room for section flag info"));
5800                   return _("<unknown>");
5801                 }
5802               size -= 2;
5803               *p++ = ',';
5804               *p++ = ' ';
5805             }
5806           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5807                    (unsigned long) unknown_flags);
5808           p += 10 + field_size;
5809         }
5810     }
5811
5812   *p = '\0';
5813   return buff;
5814 }
5815
5816 static unsigned int
5817 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5818 {
5819   if (is_32bit_elf)
5820     {
5821       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5822
5823       if (size < sizeof (* echdr))
5824         {
5825           error (_("Compressed section is too small even for a compression header\n"));
5826           return 0;
5827         }
5828
5829       chdr->ch_type = BYTE_GET (echdr->ch_type);
5830       chdr->ch_size = BYTE_GET (echdr->ch_size);
5831       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5832       return sizeof (*echdr);
5833     }
5834   else
5835     {
5836       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5837
5838       if (size < sizeof (* echdr))
5839         {
5840           error (_("Compressed section is too small even for a compression header\n"));
5841           return 0;
5842         }
5843
5844       chdr->ch_type = BYTE_GET (echdr->ch_type);
5845       chdr->ch_size = BYTE_GET (echdr->ch_size);
5846       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5847       return sizeof (*echdr);
5848     }
5849 }
5850
5851 static bfd_boolean
5852 process_section_headers (FILE * file)
5853 {
5854   Elf_Internal_Shdr * section;
5855   unsigned int i;
5856
5857   section_headers = NULL;
5858
5859   if (elf_header.e_shnum == 0)
5860     {
5861       /* PR binutils/12467.  */
5862       if (elf_header.e_shoff != 0)
5863         {
5864           warn (_("possibly corrupt ELF file header - it has a non-zero"
5865                   " section header offset, but no section headers\n"));
5866           return FALSE;
5867         }
5868       else if (do_sections)
5869         printf (_("\nThere are no sections in this file.\n"));
5870
5871       return TRUE;
5872     }
5873
5874   if (do_sections && !do_header)
5875     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5876             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5877
5878   if (is_32bit_elf)
5879     {
5880       if (! get_32bit_section_headers (file, FALSE))
5881         return FALSE;
5882     }
5883   else
5884     {
5885       if (! get_64bit_section_headers (file, FALSE))
5886         return FALSE;
5887     }
5888
5889   /* Read in the string table, so that we have names to display.  */
5890   if (elf_header.e_shstrndx != SHN_UNDEF
5891        && elf_header.e_shstrndx < elf_header.e_shnum)
5892     {
5893       section = section_headers + elf_header.e_shstrndx;
5894
5895       if (section->sh_size != 0)
5896         {
5897           string_table = (char *) get_data (NULL, file, section->sh_offset,
5898                                             1, section->sh_size,
5899                                             _("string table"));
5900
5901           string_table_length = string_table != NULL ? section->sh_size : 0;
5902         }
5903     }
5904
5905   /* Scan the sections for the dynamic symbol table
5906      and dynamic string table and debug sections.  */
5907   dynamic_symbols = NULL;
5908   dynamic_strings = NULL;
5909   dynamic_syminfo = NULL;
5910   symtab_shndx_list = NULL;
5911
5912   eh_addr_size = is_32bit_elf ? 4 : 8;
5913   switch (elf_header.e_machine)
5914     {
5915     case EM_MIPS:
5916     case EM_MIPS_RS3_LE:
5917       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5918          FDE addresses.  However, the ABI also has a semi-official ILP32
5919          variant for which the normal FDE address size rules apply.
5920
5921          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5922          section, where XX is the size of longs in bits.  Unfortunately,
5923          earlier compilers provided no way of distinguishing ILP32 objects
5924          from LP64 objects, so if there's any doubt, we should assume that
5925          the official LP64 form is being used.  */
5926       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5927           && find_section (".gcc_compiled_long32") == NULL)
5928         eh_addr_size = 8;
5929       break;
5930
5931     case EM_H8_300:
5932     case EM_H8_300H:
5933       switch (elf_header.e_flags & EF_H8_MACH)
5934         {
5935         case E_H8_MACH_H8300:
5936         case E_H8_MACH_H8300HN:
5937         case E_H8_MACH_H8300SN:
5938         case E_H8_MACH_H8300SXN:
5939           eh_addr_size = 2;
5940           break;
5941         case E_H8_MACH_H8300H:
5942         case E_H8_MACH_H8300S:
5943         case E_H8_MACH_H8300SX:
5944           eh_addr_size = 4;
5945           break;
5946         }
5947       break;
5948
5949     case EM_M32C_OLD:
5950     case EM_M32C:
5951       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5952         {
5953         case EF_M32C_CPU_M16C:
5954           eh_addr_size = 2;
5955           break;
5956         }
5957       break;
5958     }
5959
5960 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5961   do                                                                    \
5962     {                                                                   \
5963       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5964       if (section->sh_entsize != expected_entsize)                      \
5965         {                                                               \
5966           char buf[40];                                                 \
5967           sprintf_vma (buf, section->sh_entsize);                       \
5968           /* Note: coded this way so that there is a single string for  \
5969              translation.  */ \
5970           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5971           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5972                    (unsigned) expected_entsize);                        \
5973           section->sh_entsize = expected_entsize;                       \
5974         }                                                               \
5975     }                                                                   \
5976   while (0)
5977
5978 #define CHECK_ENTSIZE(section, i, type)                                 \
5979   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
5980                         sizeof (Elf64_External_##type))
5981
5982   for (i = 0, section = section_headers;
5983        i < elf_header.e_shnum;
5984        i++, section++)
5985     {
5986       char * name = SECTION_NAME (section);
5987
5988       if (section->sh_type == SHT_DYNSYM)
5989         {
5990           if (dynamic_symbols != NULL)
5991             {
5992               error (_("File contains multiple dynamic symbol tables\n"));
5993               continue;
5994             }
5995
5996           CHECK_ENTSIZE (section, i, Sym);
5997           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5998         }
5999       else if (section->sh_type == SHT_STRTAB
6000                && streq (name, ".dynstr"))
6001         {
6002           if (dynamic_strings != NULL)
6003             {
6004               error (_("File contains multiple dynamic string tables\n"));
6005               continue;
6006             }
6007
6008           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
6009                                                1, section->sh_size,
6010                                                _("dynamic strings"));
6011           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6012         }
6013       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6014         {
6015           elf_section_list * entry = xmalloc (sizeof * entry);
6016           entry->hdr = section;
6017           entry->next = symtab_shndx_list;
6018           symtab_shndx_list = entry;
6019         }
6020       else if (section->sh_type == SHT_SYMTAB)
6021         CHECK_ENTSIZE (section, i, Sym);
6022       else if (section->sh_type == SHT_GROUP)
6023         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6024       else if (section->sh_type == SHT_REL)
6025         CHECK_ENTSIZE (section, i, Rel);
6026       else if (section->sh_type == SHT_RELA)
6027         CHECK_ENTSIZE (section, i, Rela);
6028       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6029                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6030                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6031                 || do_debug_str || do_debug_loc || do_debug_ranges
6032                 || do_debug_addr || do_debug_cu_index)
6033                && (const_strneq (name, ".debug_")
6034                    || const_strneq (name, ".zdebug_")))
6035         {
6036           if (name[1] == 'z')
6037             name += sizeof (".zdebug_") - 1;
6038           else
6039             name += sizeof (".debug_") - 1;
6040
6041           if (do_debugging
6042               || (do_debug_info     && const_strneq (name, "info"))
6043               || (do_debug_info     && const_strneq (name, "types"))
6044               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6045               || (do_debug_lines    && strcmp (name, "line") == 0)
6046               || (do_debug_lines    && const_strneq (name, "line."))
6047               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6048               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6049               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6050               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6051               || (do_debug_aranges  && const_strneq (name, "aranges"))
6052               || (do_debug_ranges   && const_strneq (name, "ranges"))
6053               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6054               || (do_debug_frames   && const_strneq (name, "frame"))
6055               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6056               || (do_debug_macinfo  && const_strneq (name, "macro"))
6057               || (do_debug_str      && const_strneq (name, "str"))
6058               || (do_debug_loc      && const_strneq (name, "loc"))
6059               || (do_debug_loc      && const_strneq (name, "loclists"))
6060               || (do_debug_addr     && const_strneq (name, "addr"))
6061               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6062               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6063               )
6064             request_dump_bynumber (i, DEBUG_DUMP);
6065         }
6066       /* Linkonce section to be combined with .debug_info at link time.  */
6067       else if ((do_debugging || do_debug_info)
6068                && const_strneq (name, ".gnu.linkonce.wi."))
6069         request_dump_bynumber (i, DEBUG_DUMP);
6070       else if (do_debug_frames && streq (name, ".eh_frame"))
6071         request_dump_bynumber (i, DEBUG_DUMP);
6072       else if (do_gdb_index && (streq (name, ".gdb_index")
6073                                 || streq (name, ".debug_names")))
6074         request_dump_bynumber (i, DEBUG_DUMP);
6075       /* Trace sections for Itanium VMS.  */
6076       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6077                 || do_trace_aranges)
6078                && const_strneq (name, ".trace_"))
6079         {
6080           name += sizeof (".trace_") - 1;
6081
6082           if (do_debugging
6083               || (do_trace_info     && streq (name, "info"))
6084               || (do_trace_abbrevs  && streq (name, "abbrev"))
6085               || (do_trace_aranges  && streq (name, "aranges"))
6086               )
6087             request_dump_bynumber (i, DEBUG_DUMP);
6088         }
6089     }
6090
6091   if (! do_sections)
6092     return TRUE;
6093
6094   if (elf_header.e_shnum > 1)
6095     printf (_("\nSection Headers:\n"));
6096   else
6097     printf (_("\nSection Header:\n"));
6098
6099   if (is_32bit_elf)
6100     {
6101       if (do_section_details)
6102         {
6103           printf (_("  [Nr] Name\n"));
6104           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6105         }
6106       else
6107         printf
6108           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6109     }
6110   else if (do_wide)
6111     {
6112       if (do_section_details)
6113         {
6114           printf (_("  [Nr] Name\n"));
6115           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6116         }
6117       else
6118         printf
6119           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6120     }
6121   else
6122     {
6123       if (do_section_details)
6124         {
6125           printf (_("  [Nr] Name\n"));
6126           printf (_("       Type              Address          Offset            Link\n"));
6127           printf (_("       Size              EntSize          Info              Align\n"));
6128         }
6129       else
6130         {
6131           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6132           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6133         }
6134     }
6135
6136   if (do_section_details)
6137     printf (_("       Flags\n"));
6138
6139   for (i = 0, section = section_headers;
6140        i < elf_header.e_shnum;
6141        i++, section++)
6142     {
6143       /* Run some sanity checks on the section header.  */
6144
6145       /* Check the sh_link field.  */
6146       switch (section->sh_type)
6147         {
6148         case SHT_SYMTAB_SHNDX:
6149         case SHT_GROUP:
6150         case SHT_HASH:
6151         case SHT_GNU_HASH:
6152         case SHT_GNU_versym:
6153         case SHT_REL:
6154         case SHT_RELA:
6155           if (section->sh_link < 1
6156               || section->sh_link >= elf_header.e_shnum
6157               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6158                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6159             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6160                   i, section->sh_link);
6161           break;
6162
6163         case SHT_DYNAMIC:
6164         case SHT_SYMTAB:
6165         case SHT_DYNSYM:
6166         case SHT_GNU_verneed:
6167         case SHT_GNU_verdef:
6168         case SHT_GNU_LIBLIST:
6169           if (section->sh_link < 1
6170               || section->sh_link >= elf_header.e_shnum
6171               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6172             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6173                   i, section->sh_link);
6174           break;
6175
6176         case SHT_INIT_ARRAY:
6177         case SHT_FINI_ARRAY:
6178         case SHT_PREINIT_ARRAY:
6179           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6180             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6181                   i, section->sh_link);
6182           break;
6183
6184         default:
6185           /* FIXME: Add support for target specific section types.  */
6186 #if 0     /* Currently we do not check other section types as there are too
6187              many special cases.  Stab sections for example have a type
6188              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6189              section.  */
6190           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6191             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6192                   i, section->sh_link);
6193 #endif
6194           break;
6195         }
6196
6197       /* Check the sh_info field.  */
6198       switch (section->sh_type)
6199         {
6200         case SHT_REL:
6201         case SHT_RELA:
6202           if (section->sh_info < 1
6203               || section->sh_info >= elf_header.e_shnum
6204               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6205                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6206                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6207                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6208                   /* FIXME: Are other section types valid ?  */
6209                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6210             {
6211               if (section->sh_info == 0
6212                   && (streq (SECTION_NAME (section), ".rel.dyn")
6213                       || streq (SECTION_NAME (section), ".rela.dyn")))
6214                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6215                    of zero.  The relocations in these sections may apply
6216                    to many different sections.  */
6217                    ;
6218               else
6219                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6220                       i, section->sh_info);
6221             }
6222           break;
6223
6224         case SHT_DYNAMIC:
6225         case SHT_HASH:
6226         case SHT_SYMTAB_SHNDX:
6227         case SHT_INIT_ARRAY:
6228         case SHT_FINI_ARRAY:
6229         case SHT_PREINIT_ARRAY:
6230           if (section->sh_info != 0)
6231             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6232                   i, section->sh_info);
6233           break;
6234
6235         case SHT_GROUP:
6236         case SHT_SYMTAB:
6237         case SHT_DYNSYM:
6238           /* A symbol index - we assume that it is valid.  */
6239           break;
6240
6241         default:
6242           /* FIXME: Add support for target specific section types.  */
6243           if (section->sh_type == SHT_NOBITS)
6244             /* NOBITS section headers with non-zero sh_info fields can be
6245                created when a binary is stripped of everything but its debug
6246                information.  The stripped sections have their headers
6247                preserved but their types set to SHT_NOBITS.  So do not check
6248                this type of section.  */
6249             ;
6250           else if (section->sh_flags & SHF_INFO_LINK)
6251             {
6252               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6253                 warn (_("[%2u]: Expected link to another section in info field"), i);
6254             }
6255           else if (section->sh_type < SHT_LOOS
6256                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6257                    && section->sh_info != 0)
6258             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6259                   i, section->sh_info);
6260           break;
6261         }
6262
6263       /* Check the sh_size field.  */
6264       if (section->sh_size > current_file_size
6265           && section->sh_type != SHT_NOBITS
6266           && section->sh_type != SHT_NULL
6267           && section->sh_type < SHT_LOOS)
6268         warn (_("Size of section %u is larger than the entire file!\n"), i);
6269
6270       printf ("  [%2u] ", i);
6271       if (do_section_details)
6272         printf ("%s\n      ", printable_section_name (section));
6273       else
6274         print_symbol (-17, SECTION_NAME (section));
6275
6276       printf (do_wide ? " %-15s " : " %-15.15s ",
6277               get_section_type_name (section->sh_type));
6278
6279       if (is_32bit_elf)
6280         {
6281           const char * link_too_big = NULL;
6282
6283           print_vma (section->sh_addr, LONG_HEX);
6284
6285           printf ( " %6.6lx %6.6lx %2.2lx",
6286                    (unsigned long) section->sh_offset,
6287                    (unsigned long) section->sh_size,
6288                    (unsigned long) section->sh_entsize);
6289
6290           if (do_section_details)
6291             fputs ("  ", stdout);
6292           else
6293             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6294
6295           if (section->sh_link >= elf_header.e_shnum)
6296             {
6297               link_too_big = "";
6298               /* The sh_link value is out of range.  Normally this indicates
6299                  an error but it can have special values in Solaris binaries.  */
6300               switch (elf_header.e_machine)
6301                 {
6302                 case EM_386:
6303                 case EM_IAMCU:
6304                 case EM_X86_64:
6305                 case EM_L1OM:
6306                 case EM_K1OM:
6307                 case EM_OLD_SPARCV9:
6308                 case EM_SPARC32PLUS:
6309                 case EM_SPARCV9:
6310                 case EM_SPARC:
6311                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6312                     link_too_big = "BEFORE";
6313                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6314                     link_too_big = "AFTER";
6315                   break;
6316                 default:
6317                   break;
6318                 }
6319             }
6320
6321           if (do_section_details)
6322             {
6323               if (link_too_big != NULL && * link_too_big)
6324                 printf ("<%s> ", link_too_big);
6325               else
6326                 printf ("%2u ", section->sh_link);
6327               printf ("%3u %2lu\n", section->sh_info,
6328                       (unsigned long) section->sh_addralign);
6329             }
6330           else
6331             printf ("%2u %3u %2lu\n",
6332                     section->sh_link,
6333                     section->sh_info,
6334                     (unsigned long) section->sh_addralign);
6335
6336           if (link_too_big && ! * link_too_big)
6337             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6338                   i, section->sh_link);
6339         }
6340       else if (do_wide)
6341         {
6342           print_vma (section->sh_addr, LONG_HEX);
6343
6344           if ((long) section->sh_offset == section->sh_offset)
6345             printf (" %6.6lx", (unsigned long) section->sh_offset);
6346           else
6347             {
6348               putchar (' ');
6349               print_vma (section->sh_offset, LONG_HEX);
6350             }
6351
6352           if ((unsigned long) section->sh_size == section->sh_size)
6353             printf (" %6.6lx", (unsigned long) section->sh_size);
6354           else
6355             {
6356               putchar (' ');
6357               print_vma (section->sh_size, LONG_HEX);
6358             }
6359
6360           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6361             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6362           else
6363             {
6364               putchar (' ');
6365               print_vma (section->sh_entsize, LONG_HEX);
6366             }
6367
6368           if (do_section_details)
6369             fputs ("  ", stdout);
6370           else
6371             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6372
6373           printf ("%2u %3u ", section->sh_link, section->sh_info);
6374
6375           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6376             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6377           else
6378             {
6379               print_vma (section->sh_addralign, DEC);
6380               putchar ('\n');
6381             }
6382         }
6383       else if (do_section_details)
6384         {
6385           printf ("       %-15.15s  ",
6386                   get_section_type_name (section->sh_type));
6387           print_vma (section->sh_addr, LONG_HEX);
6388           if ((long) section->sh_offset == section->sh_offset)
6389             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6390           else
6391             {
6392               printf ("  ");
6393               print_vma (section->sh_offset, LONG_HEX);
6394             }
6395           printf ("  %u\n       ", section->sh_link);
6396           print_vma (section->sh_size, LONG_HEX);
6397           putchar (' ');
6398           print_vma (section->sh_entsize, LONG_HEX);
6399
6400           printf ("  %-16u  %lu\n",
6401                   section->sh_info,
6402                   (unsigned long) section->sh_addralign);
6403         }
6404       else
6405         {
6406           putchar (' ');
6407           print_vma (section->sh_addr, LONG_HEX);
6408           if ((long) section->sh_offset == section->sh_offset)
6409             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6410           else
6411             {
6412               printf ("  ");
6413               print_vma (section->sh_offset, LONG_HEX);
6414             }
6415           printf ("\n       ");
6416           print_vma (section->sh_size, LONG_HEX);
6417           printf ("  ");
6418           print_vma (section->sh_entsize, LONG_HEX);
6419
6420           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6421
6422           printf ("     %2u   %3u     %lu\n",
6423                   section->sh_link,
6424                   section->sh_info,
6425                   (unsigned long) section->sh_addralign);
6426         }
6427
6428       if (do_section_details)
6429         {
6430           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6431           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6432             {
6433               /* Minimum section size is 12 bytes for 32-bit compression
6434                  header + 12 bytes for compressed data header.  */
6435               unsigned char buf[24];
6436
6437               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6438               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6439                             sizeof (buf), _("compression header")))
6440                 {
6441                   Elf_Internal_Chdr chdr;
6442
6443                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6444
6445                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6446                     printf ("       ZLIB, ");
6447                   else
6448                     printf (_("       [<unknown>: 0x%x], "),
6449                             chdr.ch_type);
6450                   print_vma (chdr.ch_size, LONG_HEX);
6451                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6452                 }
6453             }
6454         }
6455     }
6456
6457   if (!do_section_details)
6458     {
6459       /* The ordering of the letters shown here matches the ordering of the
6460          corresponding SHF_xxx values, and hence the order in which these
6461          letters will be displayed to the user.  */
6462       printf (_("Key to Flags:\n\
6463   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6464   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6465   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6466       if (elf_header.e_machine == EM_X86_64
6467           || elf_header.e_machine == EM_L1OM
6468           || elf_header.e_machine == EM_K1OM)
6469         printf (_("l (large), "));
6470       else if (elf_header.e_machine == EM_ARM)
6471         printf (_("y (purecode), "));
6472       else if (elf_header.e_machine == EM_PPC)
6473         printf (_("v (VLE), "));
6474       printf ("p (processor specific)\n");
6475     }
6476
6477   return TRUE;
6478 }
6479
6480 static const char *
6481 get_group_flags (unsigned int flags)
6482 {
6483   static char buff[128];
6484
6485   if (flags == 0)
6486     return "";
6487   else if (flags == GRP_COMDAT)
6488     return "COMDAT ";
6489
6490   snprintf (buff, 14, _("[0x%x: "), flags);
6491
6492   flags &= ~ GRP_COMDAT;
6493   if (flags & GRP_MASKOS)
6494     {
6495       strcat (buff, "<OS specific>");
6496       flags &= ~ GRP_MASKOS;
6497     }
6498
6499   if (flags & GRP_MASKPROC)
6500     {
6501       strcat (buff, "<PROC specific>");
6502       flags &= ~ GRP_MASKPROC;
6503     }
6504
6505   if (flags)
6506     strcat (buff, "<unknown>");
6507
6508   strcat (buff, "]");
6509   return buff;
6510 }
6511
6512 static bfd_boolean
6513 process_section_groups (FILE * file)
6514 {
6515   Elf_Internal_Shdr * section;
6516   unsigned int i;
6517   struct group * group;
6518   Elf_Internal_Shdr * symtab_sec;
6519   Elf_Internal_Shdr * strtab_sec;
6520   Elf_Internal_Sym * symtab;
6521   unsigned long num_syms;
6522   char * strtab;
6523   size_t strtab_size;
6524
6525   /* Don't process section groups unless needed.  */
6526   if (!do_unwind && !do_section_groups)
6527     return TRUE;
6528
6529   if (elf_header.e_shnum == 0)
6530     {
6531       if (do_section_groups)
6532         printf (_("\nThere are no sections to group in this file.\n"));
6533
6534       return TRUE;
6535     }
6536
6537   if (section_headers == NULL)
6538     {
6539       error (_("Section headers are not available!\n"));
6540       /* PR 13622: This can happen with a corrupt ELF header.  */
6541       return FALSE;
6542     }
6543
6544   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6545                                                      sizeof (struct group *));
6546
6547   if (section_headers_groups == NULL)
6548     {
6549       error (_("Out of memory reading %u section group headers\n"),
6550              elf_header.e_shnum);
6551       return FALSE;
6552     }
6553
6554   /* Scan the sections for the group section.  */
6555   group_count = 0;
6556   for (i = 0, section = section_headers;
6557        i < elf_header.e_shnum;
6558        i++, section++)
6559     if (section->sh_type == SHT_GROUP)
6560       group_count++;
6561
6562   if (group_count == 0)
6563     {
6564       if (do_section_groups)
6565         printf (_("\nThere are no section groups in this file.\n"));
6566
6567       return TRUE;
6568     }
6569
6570   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6571
6572   if (section_groups == NULL)
6573     {
6574       error (_("Out of memory reading %lu groups\n"),
6575              (unsigned long) group_count);
6576       return FALSE;
6577     }
6578
6579   symtab_sec = NULL;
6580   strtab_sec = NULL;
6581   symtab = NULL;
6582   num_syms = 0;
6583   strtab = NULL;
6584   strtab_size = 0;
6585   for (i = 0, section = section_headers, group = section_groups;
6586        i < elf_header.e_shnum;
6587        i++, section++)
6588     {
6589       if (section->sh_type == SHT_GROUP)
6590         {
6591           const char * name = printable_section_name (section);
6592           const char * group_name;
6593           unsigned char * start;
6594           unsigned char * indices;
6595           unsigned int entry, j, size;
6596           Elf_Internal_Shdr * sec;
6597           Elf_Internal_Sym * sym;
6598
6599           /* Get the symbol table.  */
6600           if (section->sh_link >= elf_header.e_shnum
6601               || ((sec = section_headers + section->sh_link)->sh_type
6602                   != SHT_SYMTAB))
6603             {
6604               error (_("Bad sh_link in group section `%s'\n"), name);
6605               continue;
6606             }
6607
6608           if (symtab_sec != sec)
6609             {
6610               symtab_sec = sec;
6611               if (symtab)
6612                 free (symtab);
6613               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6614             }
6615
6616           if (symtab == NULL)
6617             {
6618               error (_("Corrupt header in group section `%s'\n"), name);
6619               continue;
6620             }
6621
6622           if (section->sh_info >= num_syms)
6623             {
6624               error (_("Bad sh_info in group section `%s'\n"), name);
6625               continue;
6626             }
6627
6628           sym = symtab + section->sh_info;
6629
6630           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6631             {
6632               if (sym->st_shndx == 0
6633                   || sym->st_shndx >= elf_header.e_shnum)
6634                 {
6635                   error (_("Bad sh_info in group section `%s'\n"), name);
6636                   continue;
6637                 }
6638
6639               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6640               strtab_sec = NULL;
6641               if (strtab)
6642                 free (strtab);
6643               strtab = NULL;
6644               strtab_size = 0;
6645             }
6646           else
6647             {
6648               /* Get the string table.  */
6649               if (symtab_sec->sh_link >= elf_header.e_shnum)
6650                 {
6651                   strtab_sec = NULL;
6652                   if (strtab)
6653                     free (strtab);
6654                   strtab = NULL;
6655                   strtab_size = 0;
6656                 }
6657               else if (strtab_sec
6658                        != (sec = section_headers + symtab_sec->sh_link))
6659                 {
6660                   strtab_sec = sec;
6661                   if (strtab)
6662                     free (strtab);
6663
6664                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6665                                               1, strtab_sec->sh_size,
6666                                               _("string table"));
6667                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6668                 }
6669               group_name = sym->st_name < strtab_size
6670                 ? strtab + sym->st_name : _("<corrupt>");
6671             }
6672
6673           /* PR 17531: file: loop.  */
6674           if (section->sh_entsize > section->sh_size)
6675             {
6676               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6677                      printable_section_name (section),
6678                      (unsigned long) section->sh_entsize,
6679                      (unsigned long) section->sh_size);
6680               break;
6681             }
6682
6683           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6684                                               1, section->sh_size,
6685                                               _("section data"));
6686           if (start == NULL)
6687             continue;
6688
6689           indices = start;
6690           size = (section->sh_size / section->sh_entsize) - 1;
6691           entry = byte_get (indices, 4);
6692           indices += 4;
6693
6694           if (do_section_groups)
6695             {
6696               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6697                       get_group_flags (entry), i, name, group_name, size);
6698
6699               printf (_("   [Index]    Name\n"));
6700             }
6701
6702           group->group_index = i;
6703
6704           for (j = 0; j < size; j++)
6705             {
6706               struct group_list * g;
6707
6708               entry = byte_get (indices, 4);
6709               indices += 4;
6710
6711               if (entry >= elf_header.e_shnum)
6712                 {
6713                   static unsigned num_group_errors = 0;
6714
6715                   if (num_group_errors ++ < 10)
6716                     {
6717                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6718                              entry, i, elf_header.e_shnum - 1);
6719                       if (num_group_errors == 10)
6720                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6721                     }
6722                   continue;
6723                 }
6724
6725               if (section_headers_groups [entry] != NULL)
6726                 {
6727                   if (entry)
6728                     {
6729                       static unsigned num_errs = 0;
6730
6731                       if (num_errs ++ < 10)
6732                         {
6733                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6734                                  entry, i,
6735                                  section_headers_groups [entry]->group_index);
6736                           if (num_errs == 10)
6737                             warn (_("Further error messages about already contained group sections suppressed\n"));
6738                         }
6739                       continue;
6740                     }
6741                   else
6742                     {
6743                       /* Intel C/C++ compiler may put section 0 in a
6744                          section group.  We just warn it the first time
6745                          and ignore it afterwards.  */
6746                       static bfd_boolean warned = FALSE;
6747                       if (!warned)
6748                         {
6749                           error (_("section 0 in group section [%5u]\n"),
6750                                  section_headers_groups [entry]->group_index);
6751                           warned = TRUE;
6752                         }
6753                     }
6754                 }
6755
6756               section_headers_groups [entry] = group;
6757
6758               if (do_section_groups)
6759                 {
6760                   sec = section_headers + entry;
6761                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6762                 }
6763
6764               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6765               g->section_index = entry;
6766               g->next = group->root;
6767               group->root = g;
6768             }
6769
6770           if (start)
6771             free (start);
6772
6773           group++;
6774         }
6775     }
6776
6777   if (symtab)
6778     free (symtab);
6779   if (strtab)
6780     free (strtab);
6781   return TRUE;
6782 }
6783
6784 /* Data used to display dynamic fixups.  */
6785
6786 struct ia64_vms_dynfixup
6787 {
6788   bfd_vma needed_ident;         /* Library ident number.  */
6789   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6790   bfd_vma fixup_needed;         /* Index of the library.  */
6791   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6792   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6793 };
6794
6795 /* Data used to display dynamic relocations.  */
6796
6797 struct ia64_vms_dynimgrela
6798 {
6799   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6800   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6801 };
6802
6803 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6804    library).  */
6805
6806 static bfd_boolean
6807 dump_ia64_vms_dynamic_fixups (FILE * file,
6808                               struct ia64_vms_dynfixup * fixup,
6809                               const char * strtab,
6810                               unsigned int strtab_sz)
6811 {
6812   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6813   long i;
6814   const char * lib_name;
6815
6816   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6817                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6818                    _("dynamic section image fixups"));
6819   if (!imfs)
6820     return FALSE;
6821
6822   if (fixup->needed < strtab_sz)
6823     lib_name = strtab + fixup->needed;
6824   else
6825     {
6826       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6827             (unsigned long) fixup->needed);
6828       lib_name = "???";
6829     }
6830   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6831           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6832   printf
6833     (_("Seg Offset           Type                             SymVec DataType\n"));
6834
6835   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6836     {
6837       unsigned int type;
6838       const char *rtype;
6839
6840       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6841       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6842       type = BYTE_GET (imfs [i].type);
6843       rtype = elf_ia64_reloc_type (type);
6844       if (rtype == NULL)
6845         printf (" 0x%08x                       ", type);
6846       else
6847         printf (" %-32s ", rtype);
6848       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6849       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6850     }
6851
6852   free (imfs);
6853   return TRUE;
6854 }
6855
6856 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6857
6858 static bfd_boolean
6859 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6860 {
6861   Elf64_External_VMS_IMAGE_RELA *imrs;
6862   long i;
6863
6864   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6865                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6866                    _("dynamic section image relocations"));
6867   if (!imrs)
6868     return FALSE;
6869
6870   printf (_("\nImage relocs\n"));
6871   printf
6872     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6873
6874   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6875     {
6876       unsigned int type;
6877       const char *rtype;
6878
6879       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6880       printf ("%08" BFD_VMA_FMT "x ",
6881               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6882       type = BYTE_GET (imrs [i].type);
6883       rtype = elf_ia64_reloc_type (type);
6884       if (rtype == NULL)
6885         printf ("0x%08x                      ", type);
6886       else
6887         printf ("%-31s ", rtype);
6888       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6889       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6890       printf ("%08" BFD_VMA_FMT "x\n",
6891               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6892     }
6893
6894   free (imrs);
6895   return TRUE;
6896 }
6897
6898 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6899
6900 static bfd_boolean
6901 process_ia64_vms_dynamic_relocs (FILE *file)
6902 {
6903   struct ia64_vms_dynfixup fixup;
6904   struct ia64_vms_dynimgrela imgrela;
6905   Elf_Internal_Dyn *entry;
6906   bfd_vma strtab_off = 0;
6907   bfd_vma strtab_sz = 0;
6908   char *strtab = NULL;
6909   bfd_boolean res = TRUE;
6910
6911   memset (&fixup, 0, sizeof (fixup));
6912   memset (&imgrela, 0, sizeof (imgrela));
6913
6914   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6915   for (entry = dynamic_section;
6916        entry < dynamic_section + dynamic_nent;
6917        entry++)
6918     {
6919       switch (entry->d_tag)
6920         {
6921         case DT_IA_64_VMS_STRTAB_OFFSET:
6922           strtab_off = entry->d_un.d_val;
6923           break;
6924         case DT_STRSZ:
6925           strtab_sz = entry->d_un.d_val;
6926           if (strtab == NULL)
6927             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6928                                1, strtab_sz, _("dynamic string section"));
6929           break;
6930
6931         case DT_IA_64_VMS_NEEDED_IDENT:
6932           fixup.needed_ident = entry->d_un.d_val;
6933           break;
6934         case DT_NEEDED:
6935           fixup.needed = entry->d_un.d_val;
6936           break;
6937         case DT_IA_64_VMS_FIXUP_NEEDED:
6938           fixup.fixup_needed = entry->d_un.d_val;
6939           break;
6940         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6941           fixup.fixup_rela_cnt = entry->d_un.d_val;
6942           break;
6943         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6944           fixup.fixup_rela_off = entry->d_un.d_val;
6945           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6946             res = FALSE;
6947           break;
6948         case DT_IA_64_VMS_IMG_RELA_CNT:
6949           imgrela.img_rela_cnt = entry->d_un.d_val;
6950           break;
6951         case DT_IA_64_VMS_IMG_RELA_OFF:
6952           imgrela.img_rela_off = entry->d_un.d_val;
6953           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6954             res = FALSE;
6955           break;
6956
6957         default:
6958           break;
6959         }
6960     }
6961
6962   if (strtab != NULL)
6963     free (strtab);
6964
6965   return res;
6966 }
6967
6968 static struct
6969 {
6970   const char * name;
6971   int reloc;
6972   int size;
6973   int rela;
6974 }
6975   dynamic_relocations [] =
6976 {
6977   { "REL", DT_REL, DT_RELSZ, FALSE },
6978   { "RELA", DT_RELA, DT_RELASZ, TRUE },
6979   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6980 };
6981
6982 /* Process the reloc section.  */
6983
6984 static bfd_boolean
6985 process_relocs (FILE * file)
6986 {
6987   unsigned long rel_size;
6988   unsigned long rel_offset;
6989
6990   if (!do_reloc)
6991     return TRUE;
6992
6993   if (do_using_dynamic)
6994     {
6995       int          is_rela;
6996       const char * name;
6997       bfd_boolean  has_dynamic_reloc;
6998       unsigned int i;
6999
7000       has_dynamic_reloc = FALSE;
7001
7002       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7003         {
7004           is_rela = dynamic_relocations [i].rela;
7005           name = dynamic_relocations [i].name;
7006           rel_size = dynamic_info [dynamic_relocations [i].size];
7007           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7008
7009           if (rel_size)
7010             has_dynamic_reloc = TRUE;
7011
7012           if (is_rela == UNKNOWN)
7013             {
7014               if (dynamic_relocations [i].reloc == DT_JMPREL)
7015                 switch (dynamic_info[DT_PLTREL])
7016                   {
7017                   case DT_REL:
7018                     is_rela = FALSE;
7019                     break;
7020                   case DT_RELA:
7021                     is_rela = TRUE;
7022                     break;
7023                   }
7024             }
7025
7026           if (rel_size)
7027             {
7028               printf
7029                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7030                  name, rel_offset, rel_size);
7031
7032               dump_relocations (file,
7033                                 offset_from_vma (file, rel_offset, rel_size),
7034                                 rel_size,
7035                                 dynamic_symbols, num_dynamic_syms,
7036                                 dynamic_strings, dynamic_strings_length,
7037                                 is_rela, TRUE /* is_dynamic */);
7038             }
7039         }
7040
7041       if (is_ia64_vms ())
7042         if (process_ia64_vms_dynamic_relocs (file))
7043           has_dynamic_reloc = TRUE;
7044
7045       if (! has_dynamic_reloc)
7046         printf (_("\nThere are no dynamic relocations in this file.\n"));
7047     }
7048   else
7049     {
7050       Elf_Internal_Shdr * section;
7051       unsigned long i;
7052       bfd_boolean found = FALSE;
7053
7054       for (i = 0, section = section_headers;
7055            i < elf_header.e_shnum;
7056            i++, section++)
7057         {
7058           if (   section->sh_type != SHT_RELA
7059               && section->sh_type != SHT_REL)
7060             continue;
7061
7062           rel_offset = section->sh_offset;
7063           rel_size   = section->sh_size;
7064
7065           if (rel_size)
7066             {
7067               Elf_Internal_Shdr * strsec;
7068               int is_rela;
7069
7070               printf (_("\nRelocation section "));
7071
7072               if (string_table == NULL)
7073                 printf ("%d", section->sh_name);
7074               else
7075                 printf ("'%s'", printable_section_name (section));
7076
7077               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7078                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7079
7080               is_rela = section->sh_type == SHT_RELA;
7081
7082               if (section->sh_link != 0
7083                   && section->sh_link < elf_header.e_shnum)
7084                 {
7085                   Elf_Internal_Shdr * symsec;
7086                   Elf_Internal_Sym *  symtab;
7087                   unsigned long nsyms;
7088                   unsigned long strtablen = 0;
7089                   char * strtab = NULL;
7090
7091                   symsec = section_headers + section->sh_link;
7092                   if (symsec->sh_type != SHT_SYMTAB
7093                       && symsec->sh_type != SHT_DYNSYM)
7094                     continue;
7095
7096                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7097
7098                   if (symtab == NULL)
7099                     continue;
7100
7101                   if (symsec->sh_link != 0
7102                       && symsec->sh_link < elf_header.e_shnum)
7103                     {
7104                       strsec = section_headers + symsec->sh_link;
7105
7106                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7107                                                   1, strsec->sh_size,
7108                                                   _("string table"));
7109                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7110                     }
7111
7112                   dump_relocations (file, rel_offset, rel_size,
7113                                     symtab, nsyms, strtab, strtablen,
7114                                     is_rela,
7115                                     symsec->sh_type == SHT_DYNSYM);
7116                   if (strtab)
7117                     free (strtab);
7118                   free (symtab);
7119                 }
7120               else
7121                 dump_relocations (file, rel_offset, rel_size,
7122                                   NULL, 0, NULL, 0, is_rela,
7123                                   FALSE /* is_dynamic */);
7124
7125               found = TRUE;
7126             }
7127         }
7128
7129       if (! found)
7130         printf (_("\nThere are no relocations in this file.\n"));
7131     }
7132
7133   return TRUE;
7134 }
7135
7136 /* An absolute address consists of a section and an offset.  If the
7137    section is NULL, the offset itself is the address, otherwise, the
7138    address equals to LOAD_ADDRESS(section) + offset.  */
7139
7140 struct absaddr
7141 {
7142   unsigned short section;
7143   bfd_vma offset;
7144 };
7145
7146 #define ABSADDR(a) \
7147   ((a).section \
7148    ? section_headers [(a).section].sh_addr + (a).offset \
7149    : (a).offset)
7150
7151 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7152    name, if found, and the offset from the symbol to ADDR.  */
7153
7154 static void
7155 find_symbol_for_address (Elf_Internal_Sym * symtab,
7156                          unsigned long      nsyms,
7157                          const char *       strtab,
7158                          unsigned long      strtab_size,
7159                          struct absaddr     addr,
7160                          const char **      symname,
7161                          bfd_vma *          offset)
7162 {
7163   bfd_vma dist = 0x100000;
7164   Elf_Internal_Sym * sym;
7165   Elf_Internal_Sym * beg;
7166   Elf_Internal_Sym * end;
7167   Elf_Internal_Sym * best = NULL;
7168
7169   REMOVE_ARCH_BITS (addr.offset);
7170   beg = symtab;
7171   end = symtab + nsyms;
7172
7173   while (beg < end)
7174     {
7175       bfd_vma value;
7176
7177       sym = beg + (end - beg) / 2;
7178
7179       value = sym->st_value;
7180       REMOVE_ARCH_BITS (value);
7181
7182       if (sym->st_name != 0
7183           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7184           && addr.offset >= value
7185           && addr.offset - value < dist)
7186         {
7187           best = sym;
7188           dist = addr.offset - value;
7189           if (!dist)
7190             break;
7191         }
7192
7193       if (addr.offset < value)
7194         end = sym;
7195       else
7196         beg = sym + 1;
7197     }
7198
7199   if (best)
7200     {
7201       *symname = (best->st_name >= strtab_size
7202                   ? _("<corrupt>") : strtab + best->st_name);
7203       *offset = dist;
7204       return;
7205     }
7206
7207   *symname = NULL;
7208   *offset = addr.offset;
7209 }
7210
7211 static /* signed */ int
7212 symcmp (const void *p, const void *q)
7213 {
7214   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7215   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7216
7217   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7218 }
7219
7220 /* Process the unwind section.  */
7221
7222 #include "unwind-ia64.h"
7223
7224 struct ia64_unw_table_entry
7225 {
7226   struct absaddr start;
7227   struct absaddr end;
7228   struct absaddr info;
7229 };
7230
7231 struct ia64_unw_aux_info
7232 {
7233   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7234   unsigned long                 table_len;      /* Length of unwind table.  */
7235   unsigned char *               info;           /* Unwind info.  */
7236   unsigned long                 info_size;      /* Size of unwind info.  */
7237   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7238   bfd_vma                       seg_base;       /* Starting address of segment.  */
7239   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7240   unsigned long                 nsyms;          /* Number of symbols.  */
7241   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7242   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7243   char *                        strtab;         /* The string table.  */
7244   unsigned long                 strtab_size;    /* Size of string table.  */
7245 };
7246
7247 static bfd_boolean
7248 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7249 {
7250   struct ia64_unw_table_entry * tp;
7251   unsigned long j, nfuns;
7252   int in_body;
7253   bfd_boolean res = TRUE;
7254
7255   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7256   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7257     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7258       aux->funtab[nfuns++] = aux->symtab[j];
7259   aux->nfuns = nfuns;
7260   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7261
7262   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7263     {
7264       bfd_vma stamp;
7265       bfd_vma offset;
7266       const unsigned char * dp;
7267       const unsigned char * head;
7268       const unsigned char * end;
7269       const char * procname;
7270
7271       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7272                                aux->strtab_size, tp->start, &procname, &offset);
7273
7274       fputs ("\n<", stdout);
7275
7276       if (procname)
7277         {
7278           fputs (procname, stdout);
7279
7280           if (offset)
7281             printf ("+%lx", (unsigned long) offset);
7282         }
7283
7284       fputs (">: [", stdout);
7285       print_vma (tp->start.offset, PREFIX_HEX);
7286       fputc ('-', stdout);
7287       print_vma (tp->end.offset, PREFIX_HEX);
7288       printf ("], info at +0x%lx\n",
7289               (unsigned long) (tp->info.offset - aux->seg_base));
7290
7291       /* PR 17531: file: 86232b32.  */
7292       if (aux->info == NULL)
7293         continue;
7294
7295       /* PR 17531: file: 0997b4d1.  */
7296       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7297         {
7298           warn (_("Invalid offset %lx in table entry %ld\n"),
7299                 (long) tp->info.offset, (long) (tp - aux->table));
7300           res = FALSE;
7301           continue;
7302         }
7303
7304       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7305       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7306
7307       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7308               (unsigned) UNW_VER (stamp),
7309               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7310               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7311               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7312               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7313
7314       if (UNW_VER (stamp) != 1)
7315         {
7316           printf (_("\tUnknown version.\n"));
7317           continue;
7318         }
7319
7320       in_body = 0;
7321       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7322       /* PR 17531: file: 16ceda89.  */
7323       if (end > aux->info + aux->info_size)
7324         end = aux->info + aux->info_size;
7325       for (dp = head + 8; dp < end;)
7326         dp = unw_decode (dp, in_body, & in_body, end);
7327     }
7328
7329   free (aux->funtab);
7330
7331   return res;
7332 }
7333
7334 static bfd_boolean
7335 slurp_ia64_unwind_table (FILE * file,
7336                          struct ia64_unw_aux_info * aux,
7337                          Elf_Internal_Shdr * sec)
7338 {
7339   unsigned long size, nrelas, i;
7340   Elf_Internal_Phdr * seg;
7341   struct ia64_unw_table_entry * tep;
7342   Elf_Internal_Shdr * relsec;
7343   Elf_Internal_Rela * rela;
7344   Elf_Internal_Rela * rp;
7345   unsigned char * table;
7346   unsigned char * tp;
7347   Elf_Internal_Sym * sym;
7348   const char * relname;
7349
7350   aux->table_len = 0;
7351
7352   /* First, find the starting address of the segment that includes
7353      this section: */
7354
7355   if (elf_header.e_phnum)
7356     {
7357       if (! get_program_headers (file))
7358           return FALSE;
7359
7360       for (seg = program_headers;
7361            seg < program_headers + elf_header.e_phnum;
7362            ++seg)
7363         {
7364           if (seg->p_type != PT_LOAD)
7365             continue;
7366
7367           if (sec->sh_addr >= seg->p_vaddr
7368               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7369             {
7370               aux->seg_base = seg->p_vaddr;
7371               break;
7372             }
7373         }
7374     }
7375
7376   /* Second, build the unwind table from the contents of the unwind section:  */
7377   size = sec->sh_size;
7378   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7379                                       _("unwind table"));
7380   if (!table)
7381     return FALSE;
7382
7383   aux->table_len = size / (3 * eh_addr_size);
7384   aux->table = (struct ia64_unw_table_entry *)
7385     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7386   tep = aux->table;
7387
7388   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7389     {
7390       tep->start.section = SHN_UNDEF;
7391       tep->end.section   = SHN_UNDEF;
7392       tep->info.section  = SHN_UNDEF;
7393       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7394       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7395       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7396       tep->start.offset += aux->seg_base;
7397       tep->end.offset   += aux->seg_base;
7398       tep->info.offset  += aux->seg_base;
7399     }
7400   free (table);
7401
7402   /* Third, apply any relocations to the unwind table:  */
7403   for (relsec = section_headers;
7404        relsec < section_headers + elf_header.e_shnum;
7405        ++relsec)
7406     {
7407       if (relsec->sh_type != SHT_RELA
7408           || relsec->sh_info >= elf_header.e_shnum
7409           || section_headers + relsec->sh_info != sec)
7410         continue;
7411
7412       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7413                               & rela, & nrelas))
7414         {
7415           free (aux->table);
7416           aux->table = NULL;
7417           aux->table_len = 0;
7418           return FALSE;
7419         }
7420
7421       for (rp = rela; rp < rela + nrelas; ++rp)
7422         {
7423           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7424           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7425
7426           /* PR 17531: file: 9fa67536.  */
7427           if (relname == NULL)
7428             {
7429               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7430               continue;
7431             }
7432
7433           if (! const_strneq (relname, "R_IA64_SEGREL"))
7434             {
7435               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7436               continue;
7437             }
7438
7439           i = rp->r_offset / (3 * eh_addr_size);
7440
7441           /* PR 17531: file: 5bc8d9bf.  */
7442           if (i >= aux->table_len)
7443             {
7444               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7445               continue;
7446             }
7447
7448           switch (rp->r_offset / eh_addr_size % 3)
7449             {
7450             case 0:
7451               aux->table[i].start.section = sym->st_shndx;
7452               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7453               break;
7454             case 1:
7455               aux->table[i].end.section   = sym->st_shndx;
7456               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7457               break;
7458             case 2:
7459               aux->table[i].info.section  = sym->st_shndx;
7460               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7461               break;
7462             default:
7463               break;
7464             }
7465         }
7466
7467       free (rela);
7468     }
7469
7470   return TRUE;
7471 }
7472
7473 static bfd_boolean
7474 ia64_process_unwind (FILE * file)
7475 {
7476   Elf_Internal_Shdr * sec;
7477   Elf_Internal_Shdr * unwsec = NULL;
7478   Elf_Internal_Shdr * strsec;
7479   unsigned long i, unwcount = 0, unwstart = 0;
7480   struct ia64_unw_aux_info aux;
7481   bfd_boolean res = TRUE;
7482
7483   memset (& aux, 0, sizeof (aux));
7484
7485   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7486     {
7487       if (sec->sh_type == SHT_SYMTAB
7488           && sec->sh_link < elf_header.e_shnum)
7489         {
7490           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7491
7492           strsec = section_headers + sec->sh_link;
7493           if (aux.strtab != NULL)
7494             {
7495               error (_("Multiple auxillary string tables encountered\n"));
7496               free (aux.strtab);
7497               res = FALSE;
7498             }
7499           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7500                                           1, strsec->sh_size,
7501                                           _("string table"));
7502           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7503         }
7504       else if (sec->sh_type == SHT_IA_64_UNWIND)
7505         unwcount++;
7506     }
7507
7508   if (!unwcount)
7509     printf (_("\nThere are no unwind sections in this file.\n"));
7510
7511   while (unwcount-- > 0)
7512     {
7513       char * suffix;
7514       size_t len, len2;
7515
7516       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7517            i < elf_header.e_shnum; ++i, ++sec)
7518         if (sec->sh_type == SHT_IA_64_UNWIND)
7519           {
7520             unwsec = sec;
7521             break;
7522           }
7523       /* We have already counted the number of SHT_IA64_UNWIND
7524          sections so the loop above should never fail.  */
7525       assert (unwsec != NULL);
7526
7527       unwstart = i + 1;
7528       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7529
7530       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7531         {
7532           /* We need to find which section group it is in.  */
7533           struct group_list * g;
7534
7535           if (section_headers_groups == NULL
7536               || section_headers_groups [i] == NULL)
7537             i = elf_header.e_shnum;
7538           else
7539             {
7540               g = section_headers_groups [i]->root;
7541
7542               for (; g != NULL; g = g->next)
7543                 {
7544                   sec = section_headers + g->section_index;
7545
7546                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7547                     break;
7548                 }
7549
7550               if (g == NULL)
7551                 i = elf_header.e_shnum;
7552             }
7553         }
7554       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7555         {
7556           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7557           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7558           suffix = SECTION_NAME (unwsec) + len;
7559           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7560                ++i, ++sec)
7561             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7562                 && streq (SECTION_NAME (sec) + len2, suffix))
7563               break;
7564         }
7565       else
7566         {
7567           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7568              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7569           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7570           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7571           suffix = "";
7572           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7573             suffix = SECTION_NAME (unwsec) + len;
7574           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7575                ++i, ++sec)
7576             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7577                 && streq (SECTION_NAME (sec) + len2, suffix))
7578               break;
7579         }
7580
7581       if (i == elf_header.e_shnum)
7582         {
7583           printf (_("\nCould not find unwind info section for "));
7584
7585           if (string_table == NULL)
7586             printf ("%d", unwsec->sh_name);
7587           else
7588             printf ("'%s'", printable_section_name (unwsec));
7589         }
7590       else
7591         {
7592           aux.info_addr = sec->sh_addr;
7593           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7594                                                  sec->sh_size,
7595                                                  _("unwind info"));
7596           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7597
7598           printf (_("\nUnwind section "));
7599
7600           if (string_table == NULL)
7601             printf ("%d", unwsec->sh_name);
7602           else
7603             printf ("'%s'", printable_section_name (unwsec));
7604
7605           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7606                   (unsigned long) unwsec->sh_offset,
7607                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7608
7609           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7610               && aux.table_len > 0)
7611             dump_ia64_unwind (& aux);
7612
7613           if (aux.table)
7614             free ((char *) aux.table);
7615           if (aux.info)
7616             free ((char *) aux.info);
7617           aux.table = NULL;
7618           aux.info = NULL;
7619         }
7620     }
7621
7622   if (aux.symtab)
7623     free (aux.symtab);
7624   if (aux.strtab)
7625     free ((char *) aux.strtab);
7626
7627   return res;
7628 }
7629
7630 struct hppa_unw_table_entry
7631 {
7632   struct absaddr start;
7633   struct absaddr end;
7634   unsigned int Cannot_unwind:1;                 /* 0 */
7635   unsigned int Millicode:1;                     /* 1 */
7636   unsigned int Millicode_save_sr0:1;            /* 2 */
7637   unsigned int Region_description:2;            /* 3..4 */
7638   unsigned int reserved1:1;                     /* 5 */
7639   unsigned int Entry_SR:1;                      /* 6 */
7640   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7641   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7642   unsigned int Args_stored:1;                   /* 16 */
7643   unsigned int Variable_Frame:1;                /* 17 */
7644   unsigned int Separate_Package_Body:1;         /* 18 */
7645   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7646   unsigned int Stack_Overflow_Check:1;          /* 20 */
7647   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7648   unsigned int Ada_Region:1;                    /* 22 */
7649   unsigned int cxx_info:1;                      /* 23 */
7650   unsigned int cxx_try_catch:1;                 /* 24 */
7651   unsigned int sched_entry_seq:1;               /* 25 */
7652   unsigned int reserved2:1;                     /* 26 */
7653   unsigned int Save_SP:1;                       /* 27 */
7654   unsigned int Save_RP:1;                       /* 28 */
7655   unsigned int Save_MRP_in_frame:1;             /* 29 */
7656   unsigned int extn_ptr_defined:1;              /* 30 */
7657   unsigned int Cleanup_defined:1;               /* 31 */
7658
7659   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7660   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7661   unsigned int Large_frame:1;                   /* 2 */
7662   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7663   unsigned int reserved4:1;                     /* 4 */
7664   unsigned int Total_frame_size:27;             /* 5..31 */
7665 };
7666
7667 struct hppa_unw_aux_info
7668 {
7669   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7670   unsigned long                  table_len;     /* Length of unwind table.  */
7671   bfd_vma                        seg_base;      /* Starting address of segment.  */
7672   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7673   unsigned long                  nsyms;         /* Number of symbols.  */
7674   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7675   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7676   char *                         strtab;        /* The string table.  */
7677   unsigned long                  strtab_size;   /* Size of string table.  */
7678 };
7679
7680 static bfd_boolean
7681 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7682 {
7683   struct hppa_unw_table_entry * tp;
7684   unsigned long j, nfuns;
7685   bfd_boolean res = TRUE;
7686
7687   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7688   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7689     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7690       aux->funtab[nfuns++] = aux->symtab[j];
7691   aux->nfuns = nfuns;
7692   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7693
7694   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7695     {
7696       bfd_vma offset;
7697       const char * procname;
7698
7699       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7700                                aux->strtab_size, tp->start, &procname,
7701                                &offset);
7702
7703       fputs ("\n<", stdout);
7704
7705       if (procname)
7706         {
7707           fputs (procname, stdout);
7708
7709           if (offset)
7710             printf ("+%lx", (unsigned long) offset);
7711         }
7712
7713       fputs (">: [", stdout);
7714       print_vma (tp->start.offset, PREFIX_HEX);
7715       fputc ('-', stdout);
7716       print_vma (tp->end.offset, PREFIX_HEX);
7717       printf ("]\n\t");
7718
7719 #define PF(_m) if (tp->_m) printf (#_m " ");
7720 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7721       PF(Cannot_unwind);
7722       PF(Millicode);
7723       PF(Millicode_save_sr0);
7724       /* PV(Region_description);  */
7725       PF(Entry_SR);
7726       PV(Entry_FR);
7727       PV(Entry_GR);
7728       PF(Args_stored);
7729       PF(Variable_Frame);
7730       PF(Separate_Package_Body);
7731       PF(Frame_Extension_Millicode);
7732       PF(Stack_Overflow_Check);
7733       PF(Two_Instruction_SP_Increment);
7734       PF(Ada_Region);
7735       PF(cxx_info);
7736       PF(cxx_try_catch);
7737       PF(sched_entry_seq);
7738       PF(Save_SP);
7739       PF(Save_RP);
7740       PF(Save_MRP_in_frame);
7741       PF(extn_ptr_defined);
7742       PF(Cleanup_defined);
7743       PF(MPE_XL_interrupt_marker);
7744       PF(HP_UX_interrupt_marker);
7745       PF(Large_frame);
7746       PF(Pseudo_SP_Set);
7747       PV(Total_frame_size);
7748 #undef PF
7749 #undef PV
7750     }
7751
7752   printf ("\n");
7753
7754   free (aux->funtab);
7755
7756   return res;
7757 }
7758
7759 static bfd_boolean
7760 slurp_hppa_unwind_table (FILE * file,
7761                          struct hppa_unw_aux_info * aux,
7762                          Elf_Internal_Shdr * sec)
7763 {
7764   unsigned long size, unw_ent_size, nentries, nrelas, i;
7765   Elf_Internal_Phdr * seg;
7766   struct hppa_unw_table_entry * tep;
7767   Elf_Internal_Shdr * relsec;
7768   Elf_Internal_Rela * rela;
7769   Elf_Internal_Rela * rp;
7770   unsigned char * table;
7771   unsigned char * tp;
7772   Elf_Internal_Sym * sym;
7773   const char * relname;
7774
7775   /* First, find the starting address of the segment that includes
7776      this section.  */
7777   if (elf_header.e_phnum)
7778     {
7779       if (! get_program_headers (file))
7780         return FALSE;
7781
7782       for (seg = program_headers;
7783            seg < program_headers + elf_header.e_phnum;
7784            ++seg)
7785         {
7786           if (seg->p_type != PT_LOAD)
7787             continue;
7788
7789           if (sec->sh_addr >= seg->p_vaddr
7790               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7791             {
7792               aux->seg_base = seg->p_vaddr;
7793               break;
7794             }
7795         }
7796     }
7797
7798   /* Second, build the unwind table from the contents of the unwind
7799      section.  */
7800   size = sec->sh_size;
7801   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7802                                       _("unwind table"));
7803   if (!table)
7804     return FALSE;
7805
7806   unw_ent_size = 16;
7807   nentries = size / unw_ent_size;
7808   size = unw_ent_size * nentries;
7809
7810   tep = aux->table = (struct hppa_unw_table_entry *)
7811       xcmalloc (nentries, sizeof (aux->table[0]));
7812
7813   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7814     {
7815       unsigned int tmp1, tmp2;
7816
7817       tep->start.section = SHN_UNDEF;
7818       tep->end.section   = SHN_UNDEF;
7819
7820       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7821       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7822       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7823       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7824
7825       tep->start.offset += aux->seg_base;
7826       tep->end.offset   += aux->seg_base;
7827
7828       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7829       tep->Millicode = (tmp1 >> 30) & 0x1;
7830       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7831       tep->Region_description = (tmp1 >> 27) & 0x3;
7832       tep->reserved1 = (tmp1 >> 26) & 0x1;
7833       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7834       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7835       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7836       tep->Args_stored = (tmp1 >> 15) & 0x1;
7837       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7838       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7839       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7840       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7841       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7842       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7843       tep->cxx_info = (tmp1 >> 8) & 0x1;
7844       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7845       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7846       tep->reserved2 = (tmp1 >> 5) & 0x1;
7847       tep->Save_SP = (tmp1 >> 4) & 0x1;
7848       tep->Save_RP = (tmp1 >> 3) & 0x1;
7849       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7850       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7851       tep->Cleanup_defined = tmp1 & 0x1;
7852
7853       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7854       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7855       tep->Large_frame = (tmp2 >> 29) & 0x1;
7856       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7857       tep->reserved4 = (tmp2 >> 27) & 0x1;
7858       tep->Total_frame_size = tmp2 & 0x7ffffff;
7859     }
7860   free (table);
7861
7862   /* Third, apply any relocations to the unwind table.  */
7863   for (relsec = section_headers;
7864        relsec < section_headers + elf_header.e_shnum;
7865        ++relsec)
7866     {
7867       if (relsec->sh_type != SHT_RELA
7868           || relsec->sh_info >= elf_header.e_shnum
7869           || section_headers + relsec->sh_info != sec)
7870         continue;
7871
7872       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7873                               & rela, & nrelas))
7874         return FALSE;
7875
7876       for (rp = rela; rp < rela + nrelas; ++rp)
7877         {
7878           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7879           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7880
7881           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7882           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7883             {
7884               warn (_("Skipping unexpected relocation type %s\n"), relname);
7885               continue;
7886             }
7887
7888           i = rp->r_offset / unw_ent_size;
7889
7890           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7891             {
7892             case 0:
7893               aux->table[i].start.section = sym->st_shndx;
7894               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7895               break;
7896             case 1:
7897               aux->table[i].end.section   = sym->st_shndx;
7898               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7899               break;
7900             default:
7901               break;
7902             }
7903         }
7904
7905       free (rela);
7906     }
7907
7908   aux->table_len = nentries;
7909
7910   return TRUE;
7911 }
7912
7913 static bfd_boolean
7914 hppa_process_unwind (FILE * file)
7915 {
7916   struct hppa_unw_aux_info aux;
7917   Elf_Internal_Shdr * unwsec = NULL;
7918   Elf_Internal_Shdr * strsec;
7919   Elf_Internal_Shdr * sec;
7920   unsigned long i;
7921   bfd_boolean res = TRUE;
7922
7923   if (string_table == NULL)
7924     return FALSE;
7925
7926   memset (& aux, 0, sizeof (aux));
7927
7928   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7929     {
7930       if (sec->sh_type == SHT_SYMTAB
7931           && sec->sh_link < elf_header.e_shnum)
7932         {
7933           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7934
7935           strsec = section_headers + sec->sh_link;
7936           if (aux.strtab != NULL)
7937             {
7938               error (_("Multiple auxillary string tables encountered\n"));
7939               free (aux.strtab);
7940               res = FALSE;
7941             }
7942           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7943                                           1, strsec->sh_size,
7944                                           _("string table"));
7945           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7946         }
7947       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7948         unwsec = sec;
7949     }
7950
7951   if (!unwsec)
7952     printf (_("\nThere are no unwind sections in this file.\n"));
7953
7954   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7955     {
7956       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7957         {
7958           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7959                   printable_section_name (sec),
7960                   (unsigned long) sec->sh_offset,
7961                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7962
7963           if (! slurp_hppa_unwind_table (file, &aux, sec))
7964             res = FALSE;
7965
7966           if (aux.table_len > 0)
7967             {
7968               if (! dump_hppa_unwind (&aux))
7969                 res = FALSE;
7970             }
7971
7972           if (aux.table)
7973             free ((char *) aux.table);
7974           aux.table = NULL;
7975         }
7976     }
7977
7978   if (aux.symtab)
7979     free (aux.symtab);
7980   if (aux.strtab)
7981     free ((char *) aux.strtab);
7982
7983   return res;
7984 }
7985
7986 struct arm_section
7987 {
7988   unsigned char *      data;            /* The unwind data.  */
7989   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
7990   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
7991   unsigned long        nrelas;          /* The number of relocations.  */
7992   unsigned int         rel_type;        /* REL or RELA ?  */
7993   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
7994 };
7995
7996 struct arm_unw_aux_info
7997 {
7998   FILE *              file;             /* The file containing the unwind sections.  */
7999   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8000   unsigned long       nsyms;            /* Number of symbols.  */
8001   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8002   unsigned long       nfuns;            /* Number of these symbols.  */
8003   char *              strtab;           /* The file's string table.  */
8004   unsigned long       strtab_size;      /* Size of string table.  */
8005 };
8006
8007 static const char *
8008 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
8009                         bfd_vma fn, struct absaddr addr)
8010 {
8011   const char *procname;
8012   bfd_vma sym_offset;
8013
8014   if (addr.section == SHN_UNDEF)
8015     addr.offset = fn;
8016
8017   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8018                            aux->strtab_size, addr, &procname,
8019                            &sym_offset);
8020
8021   print_vma (fn, PREFIX_HEX);
8022
8023   if (procname)
8024     {
8025       fputs (" <", stdout);
8026       fputs (procname, stdout);
8027
8028       if (sym_offset)
8029         printf ("+0x%lx", (unsigned long) sym_offset);
8030       fputc ('>', stdout);
8031     }
8032
8033   return procname;
8034 }
8035
8036 static void
8037 arm_free_section (struct arm_section *arm_sec)
8038 {
8039   if (arm_sec->data != NULL)
8040     free (arm_sec->data);
8041
8042   if (arm_sec->rela != NULL)
8043     free (arm_sec->rela);
8044 }
8045
8046 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8047       cached section and install SEC instead.
8048    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8049       and return its valued in * WORDP, relocating if necessary.
8050    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8051       relocation's offset in ADDR.
8052    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8053       into the string table of the symbol associated with the reloc.  If no
8054       reloc was applied store -1 there.
8055    5) Return TRUE upon success, FALSE otherwise.  */
8056
8057 static bfd_boolean
8058 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8059                          struct arm_section *       arm_sec,
8060                          Elf_Internal_Shdr *        sec,
8061                          bfd_vma                    word_offset,
8062                          unsigned int *             wordp,
8063                          struct absaddr *           addr,
8064                          bfd_vma *                  sym_name)
8065 {
8066   Elf_Internal_Rela *rp;
8067   Elf_Internal_Sym *sym;
8068   const char * relname;
8069   unsigned int word;
8070   bfd_boolean wrapped;
8071
8072   if (sec == NULL || arm_sec == NULL)
8073     return FALSE;
8074
8075   addr->section = SHN_UNDEF;
8076   addr->offset = 0;
8077
8078   if (sym_name != NULL)
8079     *sym_name = (bfd_vma) -1;
8080
8081   /* If necessary, update the section cache.  */
8082   if (sec != arm_sec->sec)
8083     {
8084       Elf_Internal_Shdr *relsec;
8085
8086       arm_free_section (arm_sec);
8087
8088       arm_sec->sec = sec;
8089       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8090                                 sec->sh_size, _("unwind data"));
8091       arm_sec->rela = NULL;
8092       arm_sec->nrelas = 0;
8093
8094       for (relsec = section_headers;
8095            relsec < section_headers + elf_header.e_shnum;
8096            ++relsec)
8097         {
8098           if (relsec->sh_info >= elf_header.e_shnum
8099               || section_headers + relsec->sh_info != sec
8100               /* PR 15745: Check the section type as well.  */
8101               || (relsec->sh_type != SHT_REL
8102                   && relsec->sh_type != SHT_RELA))
8103             continue;
8104
8105           arm_sec->rel_type = relsec->sh_type;
8106           if (relsec->sh_type == SHT_REL)
8107             {
8108               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8109                                      relsec->sh_size,
8110                                      & arm_sec->rela, & arm_sec->nrelas))
8111                 return FALSE;
8112             }
8113           else /* relsec->sh_type == SHT_RELA */
8114             {
8115               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8116                                       relsec->sh_size,
8117                                       & arm_sec->rela, & arm_sec->nrelas))
8118                 return FALSE;
8119             }
8120           break;
8121         }
8122
8123       arm_sec->next_rela = arm_sec->rela;
8124     }
8125
8126   /* If there is no unwind data we can do nothing.  */
8127   if (arm_sec->data == NULL)
8128     return FALSE;
8129
8130   /* If the offset is invalid then fail.  */
8131   if (/* PR 21343 *//* PR 18879 */
8132       sec->sh_size < 4
8133       || word_offset > (sec->sh_size - 4)
8134       || ((bfd_signed_vma) word_offset) < 0)
8135     return FALSE;
8136
8137   /* Get the word at the required offset.  */
8138   word = byte_get (arm_sec->data + word_offset, 4);
8139
8140   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8141   if (arm_sec->rela == NULL)
8142     {
8143       * wordp = word;
8144       return TRUE;
8145     }
8146
8147   /* Look through the relocs to find the one that applies to the provided offset.  */
8148   wrapped = FALSE;
8149   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8150     {
8151       bfd_vma prelval, offset;
8152
8153       if (rp->r_offset > word_offset && !wrapped)
8154         {
8155           rp = arm_sec->rela;
8156           wrapped = TRUE;
8157         }
8158       if (rp->r_offset > word_offset)
8159         break;
8160
8161       if (rp->r_offset & 3)
8162         {
8163           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8164                 (unsigned long) rp->r_offset);
8165           continue;
8166         }
8167
8168       if (rp->r_offset < word_offset)
8169         continue;
8170
8171       /* PR 17531: file: 027-161405-0.004  */
8172       if (aux->symtab == NULL)
8173         continue;
8174
8175       if (arm_sec->rel_type == SHT_REL)
8176         {
8177           offset = word & 0x7fffffff;
8178           if (offset & 0x40000000)
8179             offset |= ~ (bfd_vma) 0x7fffffff;
8180         }
8181       else if (arm_sec->rel_type == SHT_RELA)
8182         offset = rp->r_addend;
8183       else
8184         {
8185           error (_("Unknown section relocation type %d encountered\n"),
8186                  arm_sec->rel_type);
8187           break;
8188         }
8189
8190       /* PR 17531 file: 027-1241568-0.004.  */
8191       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8192         {
8193           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8194                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8195           break;
8196         }
8197
8198       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8199       offset += sym->st_value;
8200       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8201
8202       /* Check that we are processing the expected reloc type.  */
8203       if (elf_header.e_machine == EM_ARM)
8204         {
8205           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8206           if (relname == NULL)
8207             {
8208               warn (_("Skipping unknown ARM relocation type: %d\n"),
8209                     (int) ELF32_R_TYPE (rp->r_info));
8210               continue;
8211             }
8212
8213           if (streq (relname, "R_ARM_NONE"))
8214               continue;
8215
8216           if (! streq (relname, "R_ARM_PREL31"))
8217             {
8218               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8219               continue;
8220             }
8221         }
8222       else if (elf_header.e_machine == EM_TI_C6000)
8223         {
8224           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8225           if (relname == NULL)
8226             {
8227               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8228                     (int) ELF32_R_TYPE (rp->r_info));
8229               continue;
8230             }
8231
8232           if (streq (relname, "R_C6000_NONE"))
8233             continue;
8234
8235           if (! streq (relname, "R_C6000_PREL31"))
8236             {
8237               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8238               continue;
8239             }
8240
8241           prelval >>= 1;
8242         }
8243       else
8244         {
8245           /* This function currently only supports ARM and TI unwinders.  */
8246           warn (_("Only TI and ARM unwinders are currently supported\n"));
8247           break;
8248         }
8249
8250       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8251       addr->section = sym->st_shndx;
8252       addr->offset = offset;
8253
8254       if (sym_name)
8255         * sym_name = sym->st_name;
8256       break;
8257     }
8258
8259   *wordp = word;
8260   arm_sec->next_rela = rp;
8261
8262   return TRUE;
8263 }
8264
8265 static const char *tic6x_unwind_regnames[16] =
8266 {
8267   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8268   "A14", "A13", "A12", "A11", "A10",
8269   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8270 };
8271
8272 static void
8273 decode_tic6x_unwind_regmask (unsigned int mask)
8274 {
8275   int i;
8276
8277   for (i = 12; mask; mask >>= 1, i--)
8278     {
8279       if (mask & 1)
8280         {
8281           fputs (tic6x_unwind_regnames[i], stdout);
8282           if (mask > 1)
8283             fputs (", ", stdout);
8284         }
8285     }
8286 }
8287
8288 #define ADVANCE                                                 \
8289   if (remaining == 0 && more_words)                             \
8290     {                                                           \
8291       data_offset += 4;                                         \
8292       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8293                                      data_offset, & word, & addr, NULL))        \
8294         return FALSE;                                           \
8295       remaining = 4;                                            \
8296       more_words--;                                             \
8297     }                                                           \
8298
8299 #define GET_OP(OP)                      \
8300   ADVANCE;                              \
8301   if (remaining)                        \
8302     {                                   \
8303       remaining--;                      \
8304       (OP) = word >> 24;                \
8305       word <<= 8;                       \
8306     }                                   \
8307   else                                  \
8308     {                                   \
8309       printf (_("[Truncated opcode]\n"));       \
8310       return FALSE;                     \
8311     }                                   \
8312   printf ("0x%02x ", OP)
8313
8314 static bfd_boolean
8315 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8316                             unsigned int               word,
8317                             unsigned int               remaining,
8318                             unsigned int               more_words,
8319                             bfd_vma                    data_offset,
8320                             Elf_Internal_Shdr *        data_sec,
8321                             struct arm_section *       data_arm_sec)
8322 {
8323   struct absaddr addr;
8324   bfd_boolean res = TRUE;
8325
8326   /* Decode the unwinding instructions.  */
8327   while (1)
8328     {
8329       unsigned int op, op2;
8330
8331       ADVANCE;
8332       if (remaining == 0)
8333         break;
8334       remaining--;
8335       op = word >> 24;
8336       word <<= 8;
8337
8338       printf ("  0x%02x ", op);
8339
8340       if ((op & 0xc0) == 0x00)
8341         {
8342           int offset = ((op & 0x3f) << 2) + 4;
8343
8344           printf ("     vsp = vsp + %d", offset);
8345         }
8346       else if ((op & 0xc0) == 0x40)
8347         {
8348           int offset = ((op & 0x3f) << 2) + 4;
8349
8350           printf ("     vsp = vsp - %d", offset);
8351         }
8352       else if ((op & 0xf0) == 0x80)
8353         {
8354           GET_OP (op2);
8355           if (op == 0x80 && op2 == 0)
8356             printf (_("Refuse to unwind"));
8357           else
8358             {
8359               unsigned int mask = ((op & 0x0f) << 8) | op2;
8360               bfd_boolean first = TRUE;
8361               int i;
8362
8363               printf ("pop {");
8364               for (i = 0; i < 12; i++)
8365                 if (mask & (1 << i))
8366                   {
8367                     if (first)
8368                       first = FALSE;
8369                     else
8370                       printf (", ");
8371                     printf ("r%d", 4 + i);
8372                   }
8373               printf ("}");
8374             }
8375         }
8376       else if ((op & 0xf0) == 0x90)
8377         {
8378           if (op == 0x9d || op == 0x9f)
8379             printf (_("     [Reserved]"));
8380           else
8381             printf ("     vsp = r%d", op & 0x0f);
8382         }
8383       else if ((op & 0xf0) == 0xa0)
8384         {
8385           int end = 4 + (op & 0x07);
8386           bfd_boolean first = TRUE;
8387           int i;
8388
8389           printf ("     pop {");
8390           for (i = 4; i <= end; i++)
8391             {
8392               if (first)
8393                 first = FALSE;
8394               else
8395                 printf (", ");
8396               printf ("r%d", i);
8397             }
8398           if (op & 0x08)
8399             {
8400               if (!first)
8401                 printf (", ");
8402               printf ("r14");
8403             }
8404           printf ("}");
8405         }
8406       else if (op == 0xb0)
8407         printf (_("     finish"));
8408       else if (op == 0xb1)
8409         {
8410           GET_OP (op2);
8411           if (op2 == 0 || (op2 & 0xf0) != 0)
8412             printf (_("[Spare]"));
8413           else
8414             {
8415               unsigned int mask = op2 & 0x0f;
8416               bfd_boolean first = TRUE;
8417               int i;
8418
8419               printf ("pop {");
8420               for (i = 0; i < 12; i++)
8421                 if (mask & (1 << i))
8422                   {
8423                     if (first)
8424                       first = FALSE;
8425                     else
8426                       printf (", ");
8427                     printf ("r%d", i);
8428                   }
8429               printf ("}");
8430             }
8431         }
8432       else if (op == 0xb2)
8433         {
8434           unsigned char buf[9];
8435           unsigned int i, len;
8436           unsigned long offset;
8437
8438           for (i = 0; i < sizeof (buf); i++)
8439             {
8440               GET_OP (buf[i]);
8441               if ((buf[i] & 0x80) == 0)
8442                 break;
8443             }
8444           if (i == sizeof (buf))
8445             {
8446               error (_("corrupt change to vsp"));
8447               res = FALSE;
8448             }
8449           else
8450             {
8451               offset = read_uleb128 (buf, &len, buf + i + 1);
8452               assert (len == i + 1);
8453               offset = offset * 4 + 0x204;
8454               printf ("vsp = vsp + %ld", offset);
8455             }
8456         }
8457       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8458         {
8459           unsigned int first, last;
8460
8461           GET_OP (op2);
8462           first = op2 >> 4;
8463           last = op2 & 0x0f;
8464           if (op == 0xc8)
8465             first = first + 16;
8466           printf ("pop {D%d", first);
8467           if (last)
8468             printf ("-D%d", first + last);
8469           printf ("}");
8470         }
8471       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8472         {
8473           unsigned int count = op & 0x07;
8474
8475           printf ("pop {D8");
8476           if (count)
8477             printf ("-D%d", 8 + count);
8478           printf ("}");
8479         }
8480       else if (op >= 0xc0 && op <= 0xc5)
8481         {
8482           unsigned int count = op & 0x07;
8483
8484           printf ("     pop {wR10");
8485           if (count)
8486             printf ("-wR%d", 10 + count);
8487           printf ("}");
8488         }
8489       else if (op == 0xc6)
8490         {
8491           unsigned int first, last;
8492
8493           GET_OP (op2);
8494           first = op2 >> 4;
8495           last = op2 & 0x0f;
8496           printf ("pop {wR%d", first);
8497           if (last)
8498             printf ("-wR%d", first + last);
8499           printf ("}");
8500         }
8501       else if (op == 0xc7)
8502         {
8503           GET_OP (op2);
8504           if (op2 == 0 || (op2 & 0xf0) != 0)
8505             printf (_("[Spare]"));
8506           else
8507             {
8508               unsigned int mask = op2 & 0x0f;
8509               bfd_boolean first = TRUE;
8510               int i;
8511
8512               printf ("pop {");
8513               for (i = 0; i < 4; i++)
8514                 if (mask & (1 << i))
8515                   {
8516                     if (first)
8517                       first = FALSE;
8518                     else
8519                       printf (", ");
8520                     printf ("wCGR%d", i);
8521                   }
8522               printf ("}");
8523             }
8524         }
8525       else
8526         {
8527           printf (_("     [unsupported opcode]"));
8528           res = FALSE;
8529         }
8530
8531       printf ("\n");
8532     }
8533
8534   return res;
8535 }
8536
8537 static bfd_boolean
8538 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8539                               unsigned int               word,
8540                               unsigned int               remaining,
8541                               unsigned int               more_words,
8542                               bfd_vma                    data_offset,
8543                               Elf_Internal_Shdr *        data_sec,
8544                               struct arm_section *       data_arm_sec)
8545 {
8546   struct absaddr addr;
8547
8548   /* Decode the unwinding instructions.  */
8549   while (1)
8550     {
8551       unsigned int op, op2;
8552
8553       ADVANCE;
8554       if (remaining == 0)
8555         break;
8556       remaining--;
8557       op = word >> 24;
8558       word <<= 8;
8559
8560       printf ("  0x%02x ", op);
8561
8562       if ((op & 0xc0) == 0x00)
8563         {
8564           int offset = ((op & 0x3f) << 3) + 8;
8565           printf ("     sp = sp + %d", offset);
8566         }
8567       else if ((op & 0xc0) == 0x80)
8568         {
8569           GET_OP (op2);
8570           if (op == 0x80 && op2 == 0)
8571             printf (_("Refuse to unwind"));
8572           else
8573             {
8574               unsigned int mask = ((op & 0x1f) << 8) | op2;
8575               if (op & 0x20)
8576                 printf ("pop compact {");
8577               else
8578                 printf ("pop {");
8579
8580               decode_tic6x_unwind_regmask (mask);
8581               printf("}");
8582             }
8583         }
8584       else if ((op & 0xf0) == 0xc0)
8585         {
8586           unsigned int reg;
8587           unsigned int nregs;
8588           unsigned int i;
8589           const char *name;
8590           struct
8591           {
8592             unsigned int offset;
8593             unsigned int reg;
8594           } regpos[16];
8595
8596           /* Scan entire instruction first so that GET_OP output is not
8597              interleaved with disassembly.  */
8598           nregs = 0;
8599           for (i = 0; nregs < (op & 0xf); i++)
8600             {
8601               GET_OP (op2);
8602               reg = op2 >> 4;
8603               if (reg != 0xf)
8604                 {
8605                   regpos[nregs].offset = i * 2;
8606                   regpos[nregs].reg = reg;
8607                   nregs++;
8608                 }
8609
8610               reg = op2 & 0xf;
8611               if (reg != 0xf)
8612                 {
8613                   regpos[nregs].offset = i * 2 + 1;
8614                   regpos[nregs].reg = reg;
8615                   nregs++;
8616                 }
8617             }
8618
8619           printf (_("pop frame {"));
8620           reg = nregs - 1;
8621           for (i = i * 2; i > 0; i--)
8622             {
8623               if (regpos[reg].offset == i - 1)
8624                 {
8625                   name = tic6x_unwind_regnames[regpos[reg].reg];
8626                   if (reg > 0)
8627                     reg--;
8628                 }
8629               else
8630                 name = _("[pad]");
8631
8632               fputs (name, stdout);
8633               if (i > 1)
8634                 printf (", ");
8635             }
8636
8637           printf ("}");
8638         }
8639       else if (op == 0xd0)
8640         printf ("     MOV FP, SP");
8641       else if (op == 0xd1)
8642         printf ("     __c6xabi_pop_rts");
8643       else if (op == 0xd2)
8644         {
8645           unsigned char buf[9];
8646           unsigned int i, len;
8647           unsigned long offset;
8648
8649           for (i = 0; i < sizeof (buf); i++)
8650             {
8651               GET_OP (buf[i]);
8652               if ((buf[i] & 0x80) == 0)
8653                 break;
8654             }
8655           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8656           if (i == sizeof (buf))
8657             {
8658               warn (_("Corrupt stack pointer adjustment detected\n"));
8659               return FALSE;
8660             }
8661
8662           offset = read_uleb128 (buf, &len, buf + i + 1);
8663           assert (len == i + 1);
8664           offset = offset * 8 + 0x408;
8665           printf (_("sp = sp + %ld"), offset);
8666         }
8667       else if ((op & 0xf0) == 0xe0)
8668         {
8669           if ((op & 0x0f) == 7)
8670             printf ("     RETURN");
8671           else
8672             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8673         }
8674       else
8675         {
8676           printf (_("     [unsupported opcode]"));
8677         }
8678       putchar ('\n');
8679     }
8680
8681   return TRUE;
8682 }
8683
8684 static bfd_vma
8685 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8686 {
8687   bfd_vma offset;
8688
8689   offset = word & 0x7fffffff;
8690   if (offset & 0x40000000)
8691     offset |= ~ (bfd_vma) 0x7fffffff;
8692
8693   if (elf_header.e_machine == EM_TI_C6000)
8694     offset <<= 1;
8695
8696   return offset + where;
8697 }
8698
8699 static bfd_boolean
8700 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8701                    unsigned int               word,
8702                    unsigned int               remaining,
8703                    bfd_vma                    data_offset,
8704                    Elf_Internal_Shdr *        data_sec,
8705                    struct arm_section *       data_arm_sec)
8706 {
8707   int per_index;
8708   unsigned int more_words = 0;
8709   struct absaddr addr;
8710   bfd_vma sym_name = (bfd_vma) -1;
8711   bfd_boolean res = FALSE;
8712
8713   if (remaining == 0)
8714     {
8715       /* Fetch the first word.
8716          Note - when decoding an object file the address extracted
8717          here will always be 0.  So we also pass in the sym_name
8718          parameter so that we can find the symbol associated with
8719          the personality routine.  */
8720       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8721                                      & word, & addr, & sym_name))
8722         return FALSE;
8723
8724       remaining = 4;
8725     }
8726
8727   if ((word & 0x80000000) == 0)
8728     {
8729       /* Expand prel31 for personality routine.  */
8730       bfd_vma fn;
8731       const char *procname;
8732
8733       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8734       printf (_("  Personality routine: "));
8735       if (fn == 0
8736           && addr.section == SHN_UNDEF && addr.offset == 0
8737           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8738         {
8739           procname = aux->strtab + sym_name;
8740           print_vma (fn, PREFIX_HEX);
8741           if (procname)
8742             {
8743               fputs (" <", stdout);
8744               fputs (procname, stdout);
8745               fputc ('>', stdout);
8746             }
8747         }
8748       else
8749         procname = arm_print_vma_and_name (aux, fn, addr);
8750       fputc ('\n', stdout);
8751
8752       /* The GCC personality routines use the standard compact
8753          encoding, starting with one byte giving the number of
8754          words.  */
8755       if (procname != NULL
8756           && (const_strneq (procname, "__gcc_personality_v0")
8757               || const_strneq (procname, "__gxx_personality_v0")
8758               || const_strneq (procname, "__gcj_personality_v0")
8759               || const_strneq (procname, "__gnu_objc_personality_v0")))
8760         {
8761           remaining = 0;
8762           more_words = 1;
8763           ADVANCE;
8764           if (!remaining)
8765             {
8766               printf (_("  [Truncated data]\n"));
8767               return FALSE;
8768             }
8769           more_words = word >> 24;
8770           word <<= 8;
8771           remaining--;
8772           per_index = -1;
8773         }
8774       else
8775         return TRUE;
8776     }
8777   else
8778     {
8779       /* ARM EHABI Section 6.3:
8780
8781          An exception-handling table entry for the compact model looks like:
8782
8783            31 30-28 27-24 23-0
8784            -- ----- ----- ----
8785             1   0   index Data for personalityRoutine[index]    */
8786
8787       if (elf_header.e_machine == EM_ARM
8788           && (word & 0x70000000))
8789         {
8790           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8791           res = FALSE;
8792         }
8793
8794       per_index = (word >> 24) & 0x7f;
8795       printf (_("  Compact model index: %d\n"), per_index);
8796       if (per_index == 0)
8797         {
8798           more_words = 0;
8799           word <<= 8;
8800           remaining--;
8801         }
8802       else if (per_index < 3)
8803         {
8804           more_words = (word >> 16) & 0xff;
8805           word <<= 16;
8806           remaining -= 2;
8807         }
8808     }
8809
8810   switch (elf_header.e_machine)
8811     {
8812     case EM_ARM:
8813       if (per_index < 3)
8814         {
8815           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8816                                             data_offset, data_sec, data_arm_sec))
8817             res = FALSE;
8818         }
8819       else
8820         {
8821           warn (_("Unknown ARM compact model index encountered\n"));
8822           printf (_("  [reserved]\n"));
8823           res = FALSE;
8824         }
8825       break;
8826
8827     case EM_TI_C6000:
8828       if (per_index < 3)
8829         {
8830           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8831                                               data_offset, data_sec, data_arm_sec))
8832             res = FALSE;
8833         }
8834       else if (per_index < 5)
8835         {
8836           if (((word >> 17) & 0x7f) == 0x7f)
8837             printf (_("  Restore stack from frame pointer\n"));
8838           else
8839             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8840           printf (_("  Registers restored: "));
8841           if (per_index == 4)
8842             printf (" (compact) ");
8843           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8844           putchar ('\n');
8845           printf (_("  Return register: %s\n"),
8846                   tic6x_unwind_regnames[word & 0xf]);
8847         }
8848       else
8849         printf (_("  [reserved (%d)]\n"), per_index);
8850       break;
8851
8852     default:
8853       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8854              elf_header.e_machine);
8855       res = FALSE;
8856     }
8857
8858   /* Decode the descriptors.  Not implemented.  */
8859
8860   return res;
8861 }
8862
8863 static bfd_boolean
8864 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8865 {
8866   struct arm_section exidx_arm_sec, extab_arm_sec;
8867   unsigned int i, exidx_len;
8868   unsigned long j, nfuns;
8869   bfd_boolean res = TRUE;
8870
8871   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8872   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8873   exidx_len = exidx_sec->sh_size / 8;
8874
8875   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8876   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8877     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8878       aux->funtab[nfuns++] = aux->symtab[j];
8879   aux->nfuns = nfuns;
8880   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8881
8882   for (i = 0; i < exidx_len; i++)
8883     {
8884       unsigned int exidx_fn, exidx_entry;
8885       struct absaddr fn_addr, entry_addr;
8886       bfd_vma fn;
8887
8888       fputc ('\n', stdout);
8889
8890       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8891                                      8 * i, & exidx_fn, & fn_addr, NULL)
8892           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8893                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8894         {
8895           free (aux->funtab);
8896           arm_free_section (& exidx_arm_sec);
8897           arm_free_section (& extab_arm_sec);
8898           return FALSE;
8899         }
8900
8901       /* ARM EHABI, Section 5:
8902          An index table entry consists of 2 words.
8903          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8904       if (exidx_fn & 0x80000000)
8905         {
8906           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8907           res = FALSE;
8908         }
8909
8910       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8911
8912       arm_print_vma_and_name (aux, fn, fn_addr);
8913       fputs (": ", stdout);
8914
8915       if (exidx_entry == 1)
8916         {
8917           print_vma (exidx_entry, PREFIX_HEX);
8918           fputs (" [cantunwind]\n", stdout);
8919         }
8920       else if (exidx_entry & 0x80000000)
8921         {
8922           print_vma (exidx_entry, PREFIX_HEX);
8923           fputc ('\n', stdout);
8924           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8925         }
8926       else
8927         {
8928           bfd_vma table, table_offset = 0;
8929           Elf_Internal_Shdr *table_sec;
8930
8931           fputs ("@", stdout);
8932           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8933           print_vma (table, PREFIX_HEX);
8934           printf ("\n");
8935
8936           /* Locate the matching .ARM.extab.  */
8937           if (entry_addr.section != SHN_UNDEF
8938               && entry_addr.section < elf_header.e_shnum)
8939             {
8940               table_sec = section_headers + entry_addr.section;
8941               table_offset = entry_addr.offset;
8942               /* PR 18879 */
8943               if (table_offset > table_sec->sh_size
8944                   || ((bfd_signed_vma) table_offset) < 0)
8945                 {
8946                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8947                         (unsigned long) table_offset,
8948                         printable_section_name (table_sec));
8949                   res = FALSE;
8950                   continue;
8951                 }
8952             }
8953           else
8954             {
8955               table_sec = find_section_by_address (table);
8956               if (table_sec != NULL)
8957                 table_offset = table - table_sec->sh_addr;
8958             }
8959
8960           if (table_sec == NULL)
8961             {
8962               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8963                     (unsigned long) table);
8964               res = FALSE;
8965               continue;
8966             }
8967
8968           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8969                                    &extab_arm_sec))
8970             res = FALSE;
8971         }
8972     }
8973
8974   printf ("\n");
8975
8976   free (aux->funtab);
8977   arm_free_section (&exidx_arm_sec);
8978   arm_free_section (&extab_arm_sec);
8979
8980   return res;
8981 }
8982
8983 /* Used for both ARM and C6X unwinding tables.  */
8984
8985 static bfd_boolean
8986 arm_process_unwind (FILE *file)
8987 {
8988   struct arm_unw_aux_info aux;
8989   Elf_Internal_Shdr *unwsec = NULL;
8990   Elf_Internal_Shdr *strsec;
8991   Elf_Internal_Shdr *sec;
8992   unsigned long i;
8993   unsigned int sec_type;
8994   bfd_boolean res = TRUE;
8995
8996   switch (elf_header.e_machine)
8997     {
8998     case EM_ARM:
8999       sec_type = SHT_ARM_EXIDX;
9000       break;
9001
9002     case EM_TI_C6000:
9003       sec_type = SHT_C6000_UNWIND;
9004       break;
9005
9006     default:
9007       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9008              elf_header.e_machine);
9009       return FALSE;
9010     }
9011
9012   if (string_table == NULL)
9013     return FALSE;
9014
9015   memset (& aux, 0, sizeof (aux));
9016   aux.file = file;
9017
9018   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9019     {
9020       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9021         {
9022           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9023
9024           strsec = section_headers + sec->sh_link;
9025
9026           /* PR binutils/17531 file: 011-12666-0.004.  */
9027           if (aux.strtab != NULL)
9028             {
9029               error (_("Multiple string tables found in file.\n"));
9030               free (aux.strtab);
9031               res = FALSE;
9032             }
9033           aux.strtab = get_data (NULL, file, strsec->sh_offset,
9034                                  1, strsec->sh_size, _("string table"));
9035           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9036         }
9037       else if (sec->sh_type == sec_type)
9038         unwsec = sec;
9039     }
9040
9041   if (unwsec == NULL)
9042     printf (_("\nThere are no unwind sections in this file.\n"));
9043   else
9044     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9045       {
9046         if (sec->sh_type == sec_type)
9047           {
9048             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9049                     printable_section_name (sec),
9050                     (unsigned long) sec->sh_offset,
9051                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9052
9053             if (! dump_arm_unwind (&aux, sec))
9054               res = FALSE;
9055           }
9056       }
9057
9058   if (aux.symtab)
9059     free (aux.symtab);
9060   if (aux.strtab)
9061     free ((char *) aux.strtab);
9062
9063   return res;
9064 }
9065
9066 static bfd_boolean
9067 process_unwind (FILE * file)
9068 {
9069   struct unwind_handler
9070   {
9071     unsigned int machtype;
9072     bfd_boolean (* handler)(FILE *);
9073   } handlers[] =
9074   {
9075     { EM_ARM, arm_process_unwind },
9076     { EM_IA_64, ia64_process_unwind },
9077     { EM_PARISC, hppa_process_unwind },
9078     { EM_TI_C6000, arm_process_unwind },
9079     { 0, NULL }
9080   };
9081   int i;
9082
9083   if (!do_unwind)
9084     return TRUE;
9085
9086   for (i = 0; handlers[i].handler != NULL; i++)
9087     if (elf_header.e_machine == handlers[i].machtype)
9088       return handlers[i].handler (file);
9089
9090   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9091           get_machine_name (elf_header.e_machine));
9092   return TRUE;
9093 }
9094
9095 static void
9096 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9097 {
9098   switch (entry->d_tag)
9099     {
9100     case DT_MIPS_FLAGS:
9101       if (entry->d_un.d_val == 0)
9102         printf (_("NONE"));
9103       else
9104         {
9105           static const char * opts[] =
9106           {
9107             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9108             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9109             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9110             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9111             "RLD_ORDER_SAFE"
9112           };
9113           unsigned int cnt;
9114           bfd_boolean first = TRUE;
9115
9116           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9117             if (entry->d_un.d_val & (1 << cnt))
9118               {
9119                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9120                 first = FALSE;
9121               }
9122         }
9123       break;
9124
9125     case DT_MIPS_IVERSION:
9126       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9127         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9128       else
9129         {
9130           char buf[40];
9131           sprintf_vma (buf, entry->d_un.d_ptr);
9132           /* Note: coded this way so that there is a single string for translation.  */
9133           printf (_("<corrupt: %s>"), buf);
9134         }
9135       break;
9136
9137     case DT_MIPS_TIME_STAMP:
9138       {
9139         char timebuf[128];
9140         struct tm * tmp;
9141         time_t atime = entry->d_un.d_val;
9142
9143         tmp = gmtime (&atime);
9144         /* PR 17531: file: 6accc532.  */
9145         if (tmp == NULL)
9146           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9147         else
9148           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9149                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9150                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9151         printf (_("Time Stamp: %s"), timebuf);
9152       }
9153       break;
9154
9155     case DT_MIPS_RLD_VERSION:
9156     case DT_MIPS_LOCAL_GOTNO:
9157     case DT_MIPS_CONFLICTNO:
9158     case DT_MIPS_LIBLISTNO:
9159     case DT_MIPS_SYMTABNO:
9160     case DT_MIPS_UNREFEXTNO:
9161     case DT_MIPS_HIPAGENO:
9162     case DT_MIPS_DELTA_CLASS_NO:
9163     case DT_MIPS_DELTA_INSTANCE_NO:
9164     case DT_MIPS_DELTA_RELOC_NO:
9165     case DT_MIPS_DELTA_SYM_NO:
9166     case DT_MIPS_DELTA_CLASSSYM_NO:
9167     case DT_MIPS_COMPACT_SIZE:
9168       print_vma (entry->d_un.d_val, DEC);
9169       break;
9170
9171     default:
9172       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9173     }
9174     putchar ('\n');
9175 }
9176
9177 static void
9178 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9179 {
9180   switch (entry->d_tag)
9181     {
9182     case DT_HP_DLD_FLAGS:
9183       {
9184         static struct
9185         {
9186           long int bit;
9187           const char * str;
9188         }
9189         flags[] =
9190         {
9191           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9192           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9193           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9194           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9195           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9196           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9197           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9198           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9199           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9200           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9201           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9202           { DT_HP_GST, "HP_GST" },
9203           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9204           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9205           { DT_HP_NODELETE, "HP_NODELETE" },
9206           { DT_HP_GROUP, "HP_GROUP" },
9207           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9208         };
9209         bfd_boolean first = TRUE;
9210         size_t cnt;
9211         bfd_vma val = entry->d_un.d_val;
9212
9213         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9214           if (val & flags[cnt].bit)
9215             {
9216               if (! first)
9217                 putchar (' ');
9218               fputs (flags[cnt].str, stdout);
9219               first = FALSE;
9220               val ^= flags[cnt].bit;
9221             }
9222
9223         if (val != 0 || first)
9224           {
9225             if (! first)
9226               putchar (' ');
9227             print_vma (val, HEX);
9228           }
9229       }
9230       break;
9231
9232     default:
9233       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9234       break;
9235     }
9236   putchar ('\n');
9237 }
9238
9239 #ifdef BFD64
9240
9241 /* VMS vs Unix time offset and factor.  */
9242
9243 #define VMS_EPOCH_OFFSET 35067168000000000LL
9244 #define VMS_GRANULARITY_FACTOR 10000000
9245
9246 /* Display a VMS time in a human readable format.  */
9247
9248 static void
9249 print_vms_time (bfd_int64_t vmstime)
9250 {
9251   struct tm *tm;
9252   time_t unxtime;
9253
9254   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9255   tm = gmtime (&unxtime);
9256   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9257           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9258           tm->tm_hour, tm->tm_min, tm->tm_sec);
9259 }
9260 #endif /* BFD64 */
9261
9262 static void
9263 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9264 {
9265   switch (entry->d_tag)
9266     {
9267     case DT_IA_64_PLT_RESERVE:
9268       /* First 3 slots reserved.  */
9269       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9270       printf (" -- ");
9271       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9272       break;
9273
9274     case DT_IA_64_VMS_LINKTIME:
9275 #ifdef BFD64
9276       print_vms_time (entry->d_un.d_val);
9277 #endif
9278       break;
9279
9280     case DT_IA_64_VMS_LNKFLAGS:
9281       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9282       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9283         printf (" CALL_DEBUG");
9284       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9285         printf (" NOP0BUFS");
9286       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9287         printf (" P0IMAGE");
9288       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9289         printf (" MKTHREADS");
9290       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9291         printf (" UPCALLS");
9292       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9293         printf (" IMGSTA");
9294       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9295         printf (" INITIALIZE");
9296       if (entry->d_un.d_val & VMS_LF_MAIN)
9297         printf (" MAIN");
9298       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9299         printf (" EXE_INIT");
9300       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9301         printf (" TBK_IN_IMG");
9302       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9303         printf (" DBG_IN_IMG");
9304       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9305         printf (" TBK_IN_DSF");
9306       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9307         printf (" DBG_IN_DSF");
9308       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9309         printf (" SIGNATURES");
9310       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9311         printf (" REL_SEG_OFF");
9312       break;
9313
9314     default:
9315       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9316       break;
9317     }
9318   putchar ('\n');
9319 }
9320
9321 static bfd_boolean
9322 get_32bit_dynamic_section (FILE * file)
9323 {
9324   Elf32_External_Dyn * edyn;
9325   Elf32_External_Dyn * ext;
9326   Elf_Internal_Dyn * entry;
9327
9328   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9329                                           dynamic_size, _("dynamic section"));
9330   if (!edyn)
9331     return FALSE;
9332
9333   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9334      might not have the luxury of section headers.  Look for the DT_NULL
9335      terminator to determine the number of entries.  */
9336   for (ext = edyn, dynamic_nent = 0;
9337        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9338        ext++)
9339     {
9340       dynamic_nent++;
9341       if (BYTE_GET (ext->d_tag) == DT_NULL)
9342         break;
9343     }
9344
9345   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9346                                                   sizeof (* entry));
9347   if (dynamic_section == NULL)
9348     {
9349       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9350              (unsigned long) dynamic_nent);
9351       free (edyn);
9352       return FALSE;
9353     }
9354
9355   for (ext = edyn, entry = dynamic_section;
9356        entry < dynamic_section + dynamic_nent;
9357        ext++, entry++)
9358     {
9359       entry->d_tag      = BYTE_GET (ext->d_tag);
9360       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9361     }
9362
9363   free (edyn);
9364
9365   return TRUE;
9366 }
9367
9368 static bfd_boolean
9369 get_64bit_dynamic_section (FILE * file)
9370 {
9371   Elf64_External_Dyn * edyn;
9372   Elf64_External_Dyn * ext;
9373   Elf_Internal_Dyn * entry;
9374
9375   /* Read in the data.  */
9376   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9377                                           dynamic_size, _("dynamic section"));
9378   if (!edyn)
9379     return FALSE;
9380
9381   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9382      might not have the luxury of section headers.  Look for the DT_NULL
9383      terminator to determine the number of entries.  */
9384   for (ext = edyn, dynamic_nent = 0;
9385        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9386        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9387        ext++)
9388     {
9389       dynamic_nent++;
9390       if (BYTE_GET (ext->d_tag) == DT_NULL)
9391         break;
9392     }
9393
9394   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9395                                                   sizeof (* entry));
9396   if (dynamic_section == NULL)
9397     {
9398       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9399              (unsigned long) dynamic_nent);
9400       free (edyn);
9401       return FALSE;
9402     }
9403
9404   /* Convert from external to internal formats.  */
9405   for (ext = edyn, entry = dynamic_section;
9406        entry < dynamic_section + dynamic_nent;
9407        ext++, entry++)
9408     {
9409       entry->d_tag      = BYTE_GET (ext->d_tag);
9410       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9411     }
9412
9413   free (edyn);
9414
9415   return TRUE;
9416 }
9417
9418 static void
9419 print_dynamic_flags (bfd_vma flags)
9420 {
9421   bfd_boolean first = TRUE;
9422
9423   while (flags)
9424     {
9425       bfd_vma flag;
9426
9427       flag = flags & - flags;
9428       flags &= ~ flag;
9429
9430       if (first)
9431         first = FALSE;
9432       else
9433         putc (' ', stdout);
9434
9435       switch (flag)
9436         {
9437         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9438         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9439         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9440         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9441         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9442         default:                fputs (_("unknown"), stdout); break;
9443         }
9444     }
9445   puts ("");
9446 }
9447
9448 /* Parse and display the contents of the dynamic section.  */
9449
9450 static bfd_boolean
9451 process_dynamic_section (FILE * file)
9452 {
9453   Elf_Internal_Dyn * entry;
9454
9455   if (dynamic_size == 0)
9456     {
9457       if (do_dynamic)
9458         printf (_("\nThere is no dynamic section in this file.\n"));
9459
9460       return TRUE;
9461     }
9462
9463   if (is_32bit_elf)
9464     {
9465       if (! get_32bit_dynamic_section (file))
9466         return FALSE;
9467     }
9468   else
9469     {
9470       if (! get_64bit_dynamic_section (file))
9471         return FALSE;
9472     }
9473
9474   /* Find the appropriate symbol table.  */
9475   if (dynamic_symbols == NULL)
9476     {
9477       for (entry = dynamic_section;
9478            entry < dynamic_section + dynamic_nent;
9479            ++entry)
9480         {
9481           Elf_Internal_Shdr section;
9482
9483           if (entry->d_tag != DT_SYMTAB)
9484             continue;
9485
9486           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9487
9488           /* Since we do not know how big the symbol table is,
9489              we default to reading in the entire file (!) and
9490              processing that.  This is overkill, I know, but it
9491              should work.  */
9492           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9493           if ((bfd_size_type) section.sh_offset > current_file_size)
9494             {
9495               /* See PR 21379 for a reproducer.  */
9496               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9497               return FALSE;
9498             }
9499
9500           if (archive_file_offset != 0)
9501             section.sh_size = archive_file_size - section.sh_offset;
9502           else
9503             {
9504               if (fseek (file, 0, SEEK_END))
9505                 error (_("Unable to seek to end of file!\n"));
9506
9507               section.sh_size = ftell (file) - section.sh_offset;
9508             }
9509
9510           if (is_32bit_elf)
9511             section.sh_entsize = sizeof (Elf32_External_Sym);
9512           else
9513             section.sh_entsize = sizeof (Elf64_External_Sym);
9514           section.sh_name = string_table_length;
9515
9516           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9517           if (num_dynamic_syms < 1)
9518             {
9519               error (_("Unable to determine the number of symbols to load\n"));
9520               continue;
9521             }
9522         }
9523     }
9524
9525   /* Similarly find a string table.  */
9526   if (dynamic_strings == NULL)
9527     {
9528       for (entry = dynamic_section;
9529            entry < dynamic_section + dynamic_nent;
9530            ++entry)
9531         {
9532           unsigned long offset;
9533           long str_tab_len;
9534
9535           if (entry->d_tag != DT_STRTAB)
9536             continue;
9537
9538           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9539
9540           /* Since we do not know how big the string table is,
9541              we default to reading in the entire file (!) and
9542              processing that.  This is overkill, I know, but it
9543              should work.  */
9544
9545           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9546
9547           if (archive_file_offset != 0)
9548             str_tab_len = archive_file_size - offset;
9549           else
9550             {
9551               if (fseek (file, 0, SEEK_END))
9552                 error (_("Unable to seek to end of file\n"));
9553               str_tab_len = ftell (file) - offset;
9554             }
9555
9556           if (str_tab_len < 1)
9557             {
9558               error
9559                 (_("Unable to determine the length of the dynamic string table\n"));
9560               continue;
9561             }
9562
9563           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9564                                                str_tab_len,
9565                                                _("dynamic string table"));
9566           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9567           break;
9568         }
9569     }
9570
9571   /* And find the syminfo section if available.  */
9572   if (dynamic_syminfo == NULL)
9573     {
9574       unsigned long syminsz = 0;
9575
9576       for (entry = dynamic_section;
9577            entry < dynamic_section + dynamic_nent;
9578            ++entry)
9579         {
9580           if (entry->d_tag == DT_SYMINENT)
9581             {
9582               /* Note: these braces are necessary to avoid a syntax
9583                  error from the SunOS4 C compiler.  */
9584               /* PR binutils/17531: A corrupt file can trigger this test.
9585                  So do not use an assert, instead generate an error message.  */
9586               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9587                 error (_("Bad value (%d) for SYMINENT entry\n"),
9588                        (int) entry->d_un.d_val);
9589             }
9590           else if (entry->d_tag == DT_SYMINSZ)
9591             syminsz = entry->d_un.d_val;
9592           else if (entry->d_tag == DT_SYMINFO)
9593             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9594                                                       syminsz);
9595         }
9596
9597       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9598         {
9599           Elf_External_Syminfo * extsyminfo;
9600           Elf_External_Syminfo * extsym;
9601           Elf_Internal_Syminfo * syminfo;
9602
9603           /* There is a syminfo section.  Read the data.  */
9604           extsyminfo = (Elf_External_Syminfo *)
9605               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9606                         _("symbol information"));
9607           if (!extsyminfo)
9608             return FALSE;
9609
9610           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9611           if (dynamic_syminfo == NULL)
9612             {
9613               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9614                      (unsigned long) syminsz);
9615               return FALSE;
9616             }
9617
9618           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9619           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9620                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9621                ++syminfo, ++extsym)
9622             {
9623               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9624               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9625             }
9626
9627           free (extsyminfo);
9628         }
9629     }
9630
9631   if (do_dynamic && dynamic_addr)
9632     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9633             dynamic_addr, (unsigned long) dynamic_nent);
9634   if (do_dynamic)
9635     printf (_("  Tag        Type                         Name/Value\n"));
9636
9637   for (entry = dynamic_section;
9638        entry < dynamic_section + dynamic_nent;
9639        entry++)
9640     {
9641       if (do_dynamic)
9642         {
9643           const char * dtype;
9644
9645           putchar (' ');
9646           print_vma (entry->d_tag, FULL_HEX);
9647           dtype = get_dynamic_type (entry->d_tag);
9648           printf (" (%s)%*s", dtype,
9649                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9650         }
9651
9652       switch (entry->d_tag)
9653         {
9654         case DT_FLAGS:
9655           if (do_dynamic)
9656             print_dynamic_flags (entry->d_un.d_val);
9657           break;
9658
9659         case DT_AUXILIARY:
9660         case DT_FILTER:
9661         case DT_CONFIG:
9662         case DT_DEPAUDIT:
9663         case DT_AUDIT:
9664           if (do_dynamic)
9665             {
9666               switch (entry->d_tag)
9667                 {
9668                 case DT_AUXILIARY:
9669                   printf (_("Auxiliary library"));
9670                   break;
9671
9672                 case DT_FILTER:
9673                   printf (_("Filter library"));
9674                   break;
9675
9676                 case DT_CONFIG:
9677                   printf (_("Configuration file"));
9678                   break;
9679
9680                 case DT_DEPAUDIT:
9681                   printf (_("Dependency audit library"));
9682                   break;
9683
9684                 case DT_AUDIT:
9685                   printf (_("Audit library"));
9686                   break;
9687                 }
9688
9689               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9690                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9691               else
9692                 {
9693                   printf (": ");
9694                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9695                   putchar ('\n');
9696                 }
9697             }
9698           break;
9699
9700         case DT_FEATURE:
9701           if (do_dynamic)
9702             {
9703               printf (_("Flags:"));
9704
9705               if (entry->d_un.d_val == 0)
9706                 printf (_(" None\n"));
9707               else
9708                 {
9709                   unsigned long int val = entry->d_un.d_val;
9710
9711                   if (val & DTF_1_PARINIT)
9712                     {
9713                       printf (" PARINIT");
9714                       val ^= DTF_1_PARINIT;
9715                     }
9716                   if (val & DTF_1_CONFEXP)
9717                     {
9718                       printf (" CONFEXP");
9719                       val ^= DTF_1_CONFEXP;
9720                     }
9721                   if (val != 0)
9722                     printf (" %lx", val);
9723                   puts ("");
9724                 }
9725             }
9726           break;
9727
9728         case DT_POSFLAG_1:
9729           if (do_dynamic)
9730             {
9731               printf (_("Flags:"));
9732
9733               if (entry->d_un.d_val == 0)
9734                 printf (_(" None\n"));
9735               else
9736                 {
9737                   unsigned long int val = entry->d_un.d_val;
9738
9739                   if (val & DF_P1_LAZYLOAD)
9740                     {
9741                       printf (" LAZYLOAD");
9742                       val ^= DF_P1_LAZYLOAD;
9743                     }
9744                   if (val & DF_P1_GROUPPERM)
9745                     {
9746                       printf (" GROUPPERM");
9747                       val ^= DF_P1_GROUPPERM;
9748                     }
9749                   if (val != 0)
9750                     printf (" %lx", val);
9751                   puts ("");
9752                 }
9753             }
9754           break;
9755
9756         case DT_FLAGS_1:
9757           if (do_dynamic)
9758             {
9759               printf (_("Flags:"));
9760               if (entry->d_un.d_val == 0)
9761                 printf (_(" None\n"));
9762               else
9763                 {
9764                   unsigned long int val = entry->d_un.d_val;
9765
9766                   if (val & DF_1_NOW)
9767                     {
9768                       printf (" NOW");
9769                       val ^= DF_1_NOW;
9770                     }
9771                   if (val & DF_1_GLOBAL)
9772                     {
9773                       printf (" GLOBAL");
9774                       val ^= DF_1_GLOBAL;
9775                     }
9776                   if (val & DF_1_GROUP)
9777                     {
9778                       printf (" GROUP");
9779                       val ^= DF_1_GROUP;
9780                     }
9781                   if (val & DF_1_NODELETE)
9782                     {
9783                       printf (" NODELETE");
9784                       val ^= DF_1_NODELETE;
9785                     }
9786                   if (val & DF_1_LOADFLTR)
9787                     {
9788                       printf (" LOADFLTR");
9789                       val ^= DF_1_LOADFLTR;
9790                     }
9791                   if (val & DF_1_INITFIRST)
9792                     {
9793                       printf (" INITFIRST");
9794                       val ^= DF_1_INITFIRST;
9795                     }
9796                   if (val & DF_1_NOOPEN)
9797                     {
9798                       printf (" NOOPEN");
9799                       val ^= DF_1_NOOPEN;
9800                     }
9801                   if (val & DF_1_ORIGIN)
9802                     {
9803                       printf (" ORIGIN");
9804                       val ^= DF_1_ORIGIN;
9805                     }
9806                   if (val & DF_1_DIRECT)
9807                     {
9808                       printf (" DIRECT");
9809                       val ^= DF_1_DIRECT;
9810                     }
9811                   if (val & DF_1_TRANS)
9812                     {
9813                       printf (" TRANS");
9814                       val ^= DF_1_TRANS;
9815                     }
9816                   if (val & DF_1_INTERPOSE)
9817                     {
9818                       printf (" INTERPOSE");
9819                       val ^= DF_1_INTERPOSE;
9820                     }
9821                   if (val & DF_1_NODEFLIB)
9822                     {
9823                       printf (" NODEFLIB");
9824                       val ^= DF_1_NODEFLIB;
9825                     }
9826                   if (val & DF_1_NODUMP)
9827                     {
9828                       printf (" NODUMP");
9829                       val ^= DF_1_NODUMP;
9830                     }
9831                   if (val & DF_1_CONFALT)
9832                     {
9833                       printf (" CONFALT");
9834                       val ^= DF_1_CONFALT;
9835                     }
9836                   if (val & DF_1_ENDFILTEE)
9837                     {
9838                       printf (" ENDFILTEE");
9839                       val ^= DF_1_ENDFILTEE;
9840                     }
9841                   if (val & DF_1_DISPRELDNE)
9842                     {
9843                       printf (" DISPRELDNE");
9844                       val ^= DF_1_DISPRELDNE;
9845                     }
9846                   if (val & DF_1_DISPRELPND)
9847                     {
9848                       printf (" DISPRELPND");
9849                       val ^= DF_1_DISPRELPND;
9850                     }
9851                   if (val & DF_1_NODIRECT)
9852                     {
9853                       printf (" NODIRECT");
9854                       val ^= DF_1_NODIRECT;
9855                     }
9856                   if (val & DF_1_IGNMULDEF)
9857                     {
9858                       printf (" IGNMULDEF");
9859                       val ^= DF_1_IGNMULDEF;
9860                     }
9861                   if (val & DF_1_NOKSYMS)
9862                     {
9863                       printf (" NOKSYMS");
9864                       val ^= DF_1_NOKSYMS;
9865                     }
9866                   if (val & DF_1_NOHDR)
9867                     {
9868                       printf (" NOHDR");
9869                       val ^= DF_1_NOHDR;
9870                     }
9871                   if (val & DF_1_EDITED)
9872                     {
9873                       printf (" EDITED");
9874                       val ^= DF_1_EDITED;
9875                     }
9876                   if (val & DF_1_NORELOC)
9877                     {
9878                       printf (" NORELOC");
9879                       val ^= DF_1_NORELOC;
9880                     }
9881                   if (val & DF_1_SYMINTPOSE)
9882                     {
9883                       printf (" SYMINTPOSE");
9884                       val ^= DF_1_SYMINTPOSE;
9885                     }
9886                   if (val & DF_1_GLOBAUDIT)
9887                     {
9888                       printf (" GLOBAUDIT");
9889                       val ^= DF_1_GLOBAUDIT;
9890                     }
9891                   if (val & DF_1_SINGLETON)
9892                     {
9893                       printf (" SINGLETON");
9894                       val ^= DF_1_SINGLETON;
9895                     }
9896                   if (val & DF_1_STUB)
9897                     {
9898                       printf (" STUB");
9899                       val ^= DF_1_STUB;
9900                     }
9901                   if (val & DF_1_PIE)
9902                     {
9903                       printf (" PIE");
9904                       val ^= DF_1_PIE;
9905                     }
9906                   if (val != 0)
9907                     printf (" %lx", val);
9908                   puts ("");
9909                 }
9910             }
9911           break;
9912
9913         case DT_PLTREL:
9914           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9915           if (do_dynamic)
9916             puts (get_dynamic_type (entry->d_un.d_val));
9917           break;
9918
9919         case DT_NULL    :
9920         case DT_NEEDED  :
9921         case DT_PLTGOT  :
9922         case DT_HASH    :
9923         case DT_STRTAB  :
9924         case DT_SYMTAB  :
9925         case DT_RELA    :
9926         case DT_INIT    :
9927         case DT_FINI    :
9928         case DT_SONAME  :
9929         case DT_RPATH   :
9930         case DT_SYMBOLIC:
9931         case DT_REL     :
9932         case DT_DEBUG   :
9933         case DT_TEXTREL :
9934         case DT_JMPREL  :
9935         case DT_RUNPATH :
9936           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9937
9938           if (do_dynamic)
9939             {
9940               char * name;
9941
9942               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9943                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9944               else
9945                 name = NULL;
9946
9947               if (name)
9948                 {
9949                   switch (entry->d_tag)
9950                     {
9951                     case DT_NEEDED:
9952                       printf (_("Shared library: [%s]"), name);
9953
9954                       if (streq (name, program_interpreter))
9955                         printf (_(" program interpreter"));
9956                       break;
9957
9958                     case DT_SONAME:
9959                       printf (_("Library soname: [%s]"), name);
9960                       break;
9961
9962                     case DT_RPATH:
9963                       printf (_("Library rpath: [%s]"), name);
9964                       break;
9965
9966                     case DT_RUNPATH:
9967                       printf (_("Library runpath: [%s]"), name);
9968                       break;
9969
9970                     default:
9971                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9972                       break;
9973                     }
9974                 }
9975               else
9976                 print_vma (entry->d_un.d_val, PREFIX_HEX);
9977
9978               putchar ('\n');
9979             }
9980           break;
9981
9982         case DT_PLTRELSZ:
9983         case DT_RELASZ  :
9984         case DT_STRSZ   :
9985         case DT_RELSZ   :
9986         case DT_RELAENT :
9987         case DT_SYMENT  :
9988         case DT_RELENT  :
9989           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9990           /* Fall through.  */
9991         case DT_PLTPADSZ:
9992         case DT_MOVEENT :
9993         case DT_MOVESZ  :
9994         case DT_INIT_ARRAYSZ:
9995         case DT_FINI_ARRAYSZ:
9996         case DT_GNU_CONFLICTSZ:
9997         case DT_GNU_LIBLISTSZ:
9998           if (do_dynamic)
9999             {
10000               print_vma (entry->d_un.d_val, UNSIGNED);
10001               printf (_(" (bytes)\n"));
10002             }
10003           break;
10004
10005         case DT_VERDEFNUM:
10006         case DT_VERNEEDNUM:
10007         case DT_RELACOUNT:
10008         case DT_RELCOUNT:
10009           if (do_dynamic)
10010             {
10011               print_vma (entry->d_un.d_val, UNSIGNED);
10012               putchar ('\n');
10013             }
10014           break;
10015
10016         case DT_SYMINSZ:
10017         case DT_SYMINENT:
10018         case DT_SYMINFO:
10019         case DT_USED:
10020         case DT_INIT_ARRAY:
10021         case DT_FINI_ARRAY:
10022           if (do_dynamic)
10023             {
10024               if (entry->d_tag == DT_USED
10025                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10026                 {
10027                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10028
10029                   if (*name)
10030                     {
10031                       printf (_("Not needed object: [%s]\n"), name);
10032                       break;
10033                     }
10034                 }
10035
10036               print_vma (entry->d_un.d_val, PREFIX_HEX);
10037               putchar ('\n');
10038             }
10039           break;
10040
10041         case DT_BIND_NOW:
10042           /* The value of this entry is ignored.  */
10043           if (do_dynamic)
10044             putchar ('\n');
10045           break;
10046
10047         case DT_GNU_PRELINKED:
10048           if (do_dynamic)
10049             {
10050               struct tm * tmp;
10051               time_t atime = entry->d_un.d_val;
10052
10053               tmp = gmtime (&atime);
10054               /* PR 17533 file: 041-1244816-0.004.  */
10055               if (tmp == NULL)
10056                 printf (_("<corrupt time val: %lx"),
10057                         (unsigned long) atime);
10058               else
10059                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10060                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10061                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10062
10063             }
10064           break;
10065
10066         case DT_GNU_HASH:
10067           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10068           if (do_dynamic)
10069             {
10070               print_vma (entry->d_un.d_val, PREFIX_HEX);
10071               putchar ('\n');
10072             }
10073           break;
10074
10075         default:
10076           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10077             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10078               entry->d_un.d_val;
10079
10080           if (do_dynamic)
10081             {
10082               switch (elf_header.e_machine)
10083                 {
10084                 case EM_MIPS:
10085                 case EM_MIPS_RS3_LE:
10086                   dynamic_section_mips_val (entry);
10087                   break;
10088                 case EM_PARISC:
10089                   dynamic_section_parisc_val (entry);
10090                   break;
10091                 case EM_IA_64:
10092                   dynamic_section_ia64_val (entry);
10093                   break;
10094                 default:
10095                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10096                   putchar ('\n');
10097                 }
10098             }
10099           break;
10100         }
10101     }
10102
10103   return TRUE;
10104 }
10105
10106 static char *
10107 get_ver_flags (unsigned int flags)
10108 {
10109   static char buff[32];
10110
10111   buff[0] = 0;
10112
10113   if (flags == 0)
10114     return _("none");
10115
10116   if (flags & VER_FLG_BASE)
10117     strcat (buff, "BASE");
10118
10119   if (flags & VER_FLG_WEAK)
10120     {
10121       if (flags & VER_FLG_BASE)
10122         strcat (buff, " | ");
10123
10124       strcat (buff, "WEAK");
10125     }
10126
10127   if (flags & VER_FLG_INFO)
10128     {
10129       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10130         strcat (buff, " | ");
10131
10132       strcat (buff, "INFO");
10133     }
10134
10135   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10136     {
10137       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10138         strcat (buff, " | ");
10139
10140       strcat (buff, _("<unknown>"));
10141     }
10142
10143   return buff;
10144 }
10145
10146 /* Display the contents of the version sections.  */
10147
10148 static bfd_boolean
10149 process_version_sections (FILE * file)
10150 {
10151   Elf_Internal_Shdr * section;
10152   unsigned i;
10153   bfd_boolean found = FALSE;
10154
10155   if (! do_version)
10156     return TRUE;
10157
10158   for (i = 0, section = section_headers;
10159        i < elf_header.e_shnum;
10160        i++, section++)
10161     {
10162       switch (section->sh_type)
10163         {
10164         case SHT_GNU_verdef:
10165           {
10166             Elf_External_Verdef * edefs;
10167             unsigned long idx;
10168             unsigned long cnt;
10169             char * endbuf;
10170
10171             found = TRUE;
10172
10173             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10174                     printable_section_name (section),
10175                     section->sh_info);
10176
10177             printf (_("  Addr: 0x"));
10178             printf_vma (section->sh_addr);
10179             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10180                     (unsigned long) section->sh_offset, section->sh_link,
10181                     printable_section_name_from_index (section->sh_link));
10182
10183             edefs = (Elf_External_Verdef *)
10184                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10185                           _("version definition section"));
10186             if (!edefs)
10187               break;
10188             endbuf = (char *) edefs + section->sh_size;
10189
10190             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10191               {
10192                 char * vstart;
10193                 Elf_External_Verdef * edef;
10194                 Elf_Internal_Verdef ent;
10195                 Elf_External_Verdaux * eaux;
10196                 Elf_Internal_Verdaux aux;
10197                 unsigned long isum;
10198                 int j;
10199
10200                 vstart = ((char *) edefs) + idx;
10201                 if (vstart + sizeof (*edef) > endbuf)
10202                   break;
10203
10204                 edef = (Elf_External_Verdef *) vstart;
10205
10206                 ent.vd_version = BYTE_GET (edef->vd_version);
10207                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10208                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10209                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10210                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10211                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10212                 ent.vd_next    = BYTE_GET (edef->vd_next);
10213
10214                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10215                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10216
10217                 printf (_("  Index: %d  Cnt: %d  "),
10218                         ent.vd_ndx, ent.vd_cnt);
10219
10220                 /* Check for overflow.  */
10221                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10222                   break;
10223
10224                 vstart += ent.vd_aux;
10225
10226                 if (vstart + sizeof (*eaux) > endbuf)
10227                   break;
10228                 eaux = (Elf_External_Verdaux *) vstart;
10229
10230                 aux.vda_name = BYTE_GET (eaux->vda_name);
10231                 aux.vda_next = BYTE_GET (eaux->vda_next);
10232
10233                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10234                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10235                 else
10236                   printf (_("Name index: %ld\n"), aux.vda_name);
10237
10238                 isum = idx + ent.vd_aux;
10239
10240                 for (j = 1; j < ent.vd_cnt; j++)
10241                   {
10242                     if (aux.vda_next < sizeof (*eaux)
10243                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10244                       {
10245                         warn (_("Invalid vda_next field of %lx\n"),
10246                               aux.vda_next);
10247                         j = ent.vd_cnt;
10248                         break;
10249                       }
10250                     /* Check for overflow.  */
10251                     if (aux.vda_next > (size_t) (endbuf - vstart))
10252                       break;
10253
10254                     isum   += aux.vda_next;
10255                     vstart += aux.vda_next;
10256
10257                     if (vstart + sizeof (*eaux) > endbuf)
10258                       break;
10259                     eaux = (Elf_External_Verdaux *) vstart;
10260
10261                     aux.vda_name = BYTE_GET (eaux->vda_name);
10262                     aux.vda_next = BYTE_GET (eaux->vda_next);
10263
10264                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10265                       printf (_("  %#06lx: Parent %d: %s\n"),
10266                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10267                     else
10268                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10269                               isum, j, aux.vda_name);
10270                   }
10271
10272                 if (j < ent.vd_cnt)
10273                   printf (_("  Version def aux past end of section\n"));
10274
10275                 /* PR 17531:
10276                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10277                 if (ent.vd_next < sizeof (*edef)
10278                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10279                   {
10280                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10281                     cnt = section->sh_info;
10282                     break;
10283                   }
10284                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10285                   break;
10286
10287                 idx += ent.vd_next;
10288               }
10289
10290             if (cnt < section->sh_info)
10291               printf (_("  Version definition past end of section\n"));
10292
10293             free (edefs);
10294           }
10295           break;
10296
10297         case SHT_GNU_verneed:
10298           {
10299             Elf_External_Verneed * eneed;
10300             unsigned long idx;
10301             unsigned long cnt;
10302             char * endbuf;
10303
10304             found = TRUE;
10305
10306             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10307                     printable_section_name (section), section->sh_info);
10308
10309             printf (_(" Addr: 0x"));
10310             printf_vma (section->sh_addr);
10311             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10312                     (unsigned long) section->sh_offset, section->sh_link,
10313                     printable_section_name_from_index (section->sh_link));
10314
10315             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10316                                                        section->sh_offset, 1,
10317                                                        section->sh_size,
10318                                                        _("Version Needs section"));
10319             if (!eneed)
10320               break;
10321             endbuf = (char *) eneed + section->sh_size;
10322
10323             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10324               {
10325                 Elf_External_Verneed * entry;
10326                 Elf_Internal_Verneed ent;
10327                 unsigned long isum;
10328                 int j;
10329                 char * vstart;
10330
10331                 vstart = ((char *) eneed) + idx;
10332                 if (vstart + sizeof (*entry) > endbuf)
10333                   break;
10334
10335                 entry = (Elf_External_Verneed *) vstart;
10336
10337                 ent.vn_version = BYTE_GET (entry->vn_version);
10338                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10339                 ent.vn_file    = BYTE_GET (entry->vn_file);
10340                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10341                 ent.vn_next    = BYTE_GET (entry->vn_next);
10342
10343                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10344
10345                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10346                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10347                 else
10348                   printf (_("  File: %lx"), ent.vn_file);
10349
10350                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10351
10352                 /* Check for overflow.  */
10353                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10354                   break;
10355                 vstart += ent.vn_aux;
10356
10357                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10358                   {
10359                     Elf_External_Vernaux * eaux;
10360                     Elf_Internal_Vernaux aux;
10361
10362                     if (vstart + sizeof (*eaux) > endbuf)
10363                       break;
10364                     eaux = (Elf_External_Vernaux *) vstart;
10365
10366                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10367                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10368                     aux.vna_other = BYTE_GET (eaux->vna_other);
10369                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10370                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10371
10372                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10373                       printf (_("  %#06lx:   Name: %s"),
10374                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10375                     else
10376                       printf (_("  %#06lx:   Name index: %lx"),
10377                               isum, aux.vna_name);
10378
10379                     printf (_("  Flags: %s  Version: %d\n"),
10380                             get_ver_flags (aux.vna_flags), aux.vna_other);
10381
10382                     if (aux.vna_next < sizeof (*eaux)
10383                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10384                       {
10385                         warn (_("Invalid vna_next field of %lx\n"),
10386                               aux.vna_next);
10387                         j = ent.vn_cnt;
10388                         break;
10389                       }
10390                     /* Check for overflow.  */
10391                     if (aux.vna_next > (size_t) (endbuf - vstart))
10392                       break;
10393                     isum   += aux.vna_next;
10394                     vstart += aux.vna_next;
10395                   }
10396
10397                 if (j < ent.vn_cnt)
10398                   warn (_("Missing Version Needs auxillary information\n"));
10399
10400                 if (ent.vn_next < sizeof (*entry)
10401                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10402                   {
10403                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10404                     cnt = section->sh_info;
10405                     break;
10406                   }
10407                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10408                   break;
10409                 idx += ent.vn_next;
10410               }
10411
10412             if (cnt < section->sh_info)
10413               warn (_("Missing Version Needs information\n"));
10414
10415             free (eneed);
10416           }
10417           break;
10418
10419         case SHT_GNU_versym:
10420           {
10421             Elf_Internal_Shdr * link_section;
10422             size_t total;
10423             unsigned int cnt;
10424             unsigned char * edata;
10425             unsigned short * data;
10426             char * strtab;
10427             Elf_Internal_Sym * symbols;
10428             Elf_Internal_Shdr * string_sec;
10429             unsigned long num_syms;
10430             long off;
10431
10432             if (section->sh_link >= elf_header.e_shnum)
10433               break;
10434
10435             link_section = section_headers + section->sh_link;
10436             total = section->sh_size / sizeof (Elf_External_Versym);
10437
10438             if (link_section->sh_link >= elf_header.e_shnum)
10439               break;
10440
10441             found = TRUE;
10442
10443             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10444             if (symbols == NULL)
10445               break;
10446
10447             string_sec = section_headers + link_section->sh_link;
10448
10449             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10450                                         string_sec->sh_size,
10451                                         _("version string table"));
10452             if (!strtab)
10453               {
10454                 free (symbols);
10455                 break;
10456               }
10457
10458             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10459                     printable_section_name (section), (unsigned long) total);
10460
10461             printf (_(" Addr: "));
10462             printf_vma (section->sh_addr);
10463             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10464                     (unsigned long) section->sh_offset, section->sh_link,
10465                     printable_section_name (link_section));
10466
10467             off = offset_from_vma (file,
10468                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10469                                    total * sizeof (short));
10470             edata = (unsigned char *) get_data (NULL, file, off, total,
10471                                                 sizeof (short),
10472                                                 _("version symbol data"));
10473             if (!edata)
10474               {
10475                 free (strtab);
10476                 free (symbols);
10477                 break;
10478               }
10479
10480             data = (short unsigned int *) cmalloc (total, sizeof (short));
10481
10482             for (cnt = total; cnt --;)
10483               data[cnt] = byte_get (edata + cnt * sizeof (short),
10484                                     sizeof (short));
10485
10486             free (edata);
10487
10488             for (cnt = 0; cnt < total; cnt += 4)
10489               {
10490                 int j, nn;
10491                 char *name;
10492                 char *invalid = _("*invalid*");
10493
10494                 printf ("  %03x:", cnt);
10495
10496                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10497                   switch (data[cnt + j])
10498                     {
10499                     case 0:
10500                       fputs (_("   0 (*local*)    "), stdout);
10501                       break;
10502
10503                     case 1:
10504                       fputs (_("   1 (*global*)   "), stdout);
10505                       break;
10506
10507                     default:
10508                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10509                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10510
10511                       /* If this index value is greater than the size of the symbols
10512                          array, break to avoid an out-of-bounds read.  */
10513                       if ((unsigned long)(cnt + j) >= num_syms)
10514                         {
10515                           warn (_("invalid index into symbol array\n"));
10516                           break;
10517                         }
10518
10519                       name = NULL;
10520                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10521                         {
10522                           Elf_Internal_Verneed ivn;
10523                           unsigned long offset;
10524
10525                           offset = offset_from_vma
10526                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10527                              sizeof (Elf_External_Verneed));
10528
10529                           do
10530                             {
10531                               Elf_Internal_Vernaux ivna;
10532                               Elf_External_Verneed evn;
10533                               Elf_External_Vernaux evna;
10534                               unsigned long a_off;
10535
10536                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10537                                             _("version need")) == NULL)
10538                                 break;
10539
10540                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10541                               ivn.vn_next = BYTE_GET (evn.vn_next);
10542
10543                               a_off = offset + ivn.vn_aux;
10544
10545                               do
10546                                 {
10547                                   if (get_data (&evna, file, a_off, sizeof (evna),
10548                                                 1, _("version need aux (2)")) == NULL)
10549                                     {
10550                                       ivna.vna_next  = 0;
10551                                       ivna.vna_other = 0;
10552                                     }
10553                                   else
10554                                     {
10555                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10556                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10557                                     }
10558
10559                                   a_off += ivna.vna_next;
10560                                 }
10561                               while (ivna.vna_other != data[cnt + j]
10562                                      && ivna.vna_next != 0);
10563
10564                               if (ivna.vna_other == data[cnt + j])
10565                                 {
10566                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10567
10568                                   if (ivna.vna_name >= string_sec->sh_size)
10569                                     name = invalid;
10570                                   else
10571                                     name = strtab + ivna.vna_name;
10572                                   break;
10573                                 }
10574
10575                               offset += ivn.vn_next;
10576                             }
10577                           while (ivn.vn_next);
10578                         }
10579
10580                       if (data[cnt + j] != 0x8001
10581                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10582                         {
10583                           Elf_Internal_Verdef ivd;
10584                           Elf_External_Verdef evd;
10585                           unsigned long offset;
10586
10587                           offset = offset_from_vma
10588                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10589                              sizeof evd);
10590
10591                           do
10592                             {
10593                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10594                                             _("version def")) == NULL)
10595                                 {
10596                                   ivd.vd_next = 0;
10597                                   /* PR 17531: file: 046-1082287-0.004.  */
10598                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10599                                   break;
10600                                 }
10601                               else
10602                                 {
10603                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10604                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10605                                 }
10606
10607                               offset += ivd.vd_next;
10608                             }
10609                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10610                                  && ivd.vd_next != 0);
10611
10612                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10613                             {
10614                               Elf_External_Verdaux evda;
10615                               Elf_Internal_Verdaux ivda;
10616
10617                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10618
10619                               if (get_data (&evda, file,
10620                                             offset - ivd.vd_next + ivd.vd_aux,
10621                                             sizeof (evda), 1,
10622                                             _("version def aux")) == NULL)
10623                                 break;
10624
10625                               ivda.vda_name = BYTE_GET (evda.vda_name);
10626
10627                               if (ivda.vda_name >= string_sec->sh_size)
10628                                 name = invalid;
10629                               else if (name != NULL && name != invalid)
10630                                 name = _("*both*");
10631                               else
10632                                 name = strtab + ivda.vda_name;
10633                             }
10634                         }
10635                       if (name != NULL)
10636                         nn += printf ("(%s%-*s",
10637                                       name,
10638                                       12 - (int) strlen (name),
10639                                       ")");
10640
10641                       if (nn < 18)
10642                         printf ("%*c", 18 - nn, ' ');
10643                     }
10644
10645                 putchar ('\n');
10646               }
10647
10648             free (data);
10649             free (strtab);
10650             free (symbols);
10651           }
10652           break;
10653
10654         default:
10655           break;
10656         }
10657     }
10658
10659   if (! found)
10660     printf (_("\nNo version information found in this file.\n"));
10661
10662   return TRUE;
10663 }
10664
10665 static const char *
10666 get_symbol_binding (unsigned int binding)
10667 {
10668   static char buff[32];
10669
10670   switch (binding)
10671     {
10672     case STB_LOCAL:     return "LOCAL";
10673     case STB_GLOBAL:    return "GLOBAL";
10674     case STB_WEAK:      return "WEAK";
10675     default:
10676       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10677         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10678                   binding);
10679       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10680         {
10681           if (binding == STB_GNU_UNIQUE
10682               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10683                   /* GNU is still using the default value 0.  */
10684                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10685             return "UNIQUE";
10686           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10687         }
10688       else
10689         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10690       return buff;
10691     }
10692 }
10693
10694 static const char *
10695 get_symbol_type (unsigned int type)
10696 {
10697   static char buff[32];
10698
10699   switch (type)
10700     {
10701     case STT_NOTYPE:    return "NOTYPE";
10702     case STT_OBJECT:    return "OBJECT";
10703     case STT_FUNC:      return "FUNC";
10704     case STT_SECTION:   return "SECTION";
10705     case STT_FILE:      return "FILE";
10706     case STT_COMMON:    return "COMMON";
10707     case STT_TLS:       return "TLS";
10708     case STT_RELC:      return "RELC";
10709     case STT_SRELC:     return "SRELC";
10710     default:
10711       if (type >= STT_LOPROC && type <= STT_HIPROC)
10712         {
10713           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10714             return "THUMB_FUNC";
10715
10716           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10717             return "REGISTER";
10718
10719           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10720             return "PARISC_MILLI";
10721
10722           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10723         }
10724       else if (type >= STT_LOOS && type <= STT_HIOS)
10725         {
10726           if (elf_header.e_machine == EM_PARISC)
10727             {
10728               if (type == STT_HP_OPAQUE)
10729                 return "HP_OPAQUE";
10730               if (type == STT_HP_STUB)
10731                 return "HP_STUB";
10732             }
10733
10734           if (type == STT_GNU_IFUNC
10735               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10736                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10737                   /* GNU is still using the default value 0.  */
10738                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10739             return "IFUNC";
10740
10741           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10742         }
10743       else
10744         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10745       return buff;
10746     }
10747 }
10748
10749 static const char *
10750 get_symbol_visibility (unsigned int visibility)
10751 {
10752   switch (visibility)
10753     {
10754     case STV_DEFAULT:   return "DEFAULT";
10755     case STV_INTERNAL:  return "INTERNAL";
10756     case STV_HIDDEN:    return "HIDDEN";
10757     case STV_PROTECTED: return "PROTECTED";
10758     default:
10759       error (_("Unrecognized visibility value: %u"), visibility);
10760       return _("<unknown>");
10761     }
10762 }
10763
10764 static const char *
10765 get_solaris_symbol_visibility (unsigned int visibility)
10766 {
10767   switch (visibility)
10768     {
10769     case 4: return "EXPORTED";
10770     case 5: return "SINGLETON";
10771     case 6: return "ELIMINATE";
10772     default: return get_symbol_visibility (visibility);
10773     }
10774 }
10775
10776 static const char *
10777 get_mips_symbol_other (unsigned int other)
10778 {
10779   switch (other)
10780     {
10781     case STO_OPTIONAL:      return "OPTIONAL";
10782     case STO_MIPS_PLT:      return "MIPS PLT";
10783     case STO_MIPS_PIC:      return "MIPS PIC";
10784     case STO_MICROMIPS:     return "MICROMIPS";
10785     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10786     case STO_MIPS16:        return "MIPS16";
10787     default:                return NULL;
10788     }
10789 }
10790
10791 static const char *
10792 get_ia64_symbol_other (unsigned int other)
10793 {
10794   if (is_ia64_vms ())
10795     {
10796       static char res[32];
10797
10798       res[0] = 0;
10799
10800       /* Function types is for images and .STB files only.  */
10801       switch (elf_header.e_type)
10802         {
10803         case ET_DYN:
10804         case ET_EXEC:
10805           switch (VMS_ST_FUNC_TYPE (other))
10806             {
10807             case VMS_SFT_CODE_ADDR:
10808               strcat (res, " CA");
10809               break;
10810             case VMS_SFT_SYMV_IDX:
10811               strcat (res, " VEC");
10812               break;
10813             case VMS_SFT_FD:
10814               strcat (res, " FD");
10815               break;
10816             case VMS_SFT_RESERVE:
10817               strcat (res, " RSV");
10818               break;
10819             default:
10820               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10821                     VMS_ST_FUNC_TYPE (other));
10822               strcat (res, " <unknown>");
10823               break;
10824             }
10825           break;
10826         default:
10827           break;
10828         }
10829       switch (VMS_ST_LINKAGE (other))
10830         {
10831         case VMS_STL_IGNORE:
10832           strcat (res, " IGN");
10833           break;
10834         case VMS_STL_RESERVE:
10835           strcat (res, " RSV");
10836           break;
10837         case VMS_STL_STD:
10838           strcat (res, " STD");
10839           break;
10840         case VMS_STL_LNK:
10841           strcat (res, " LNK");
10842           break;
10843         default:
10844           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10845                 VMS_ST_LINKAGE (other));
10846           strcat (res, " <unknown>");
10847           break;
10848         }
10849
10850       if (res[0] != 0)
10851         return res + 1;
10852       else
10853         return res;
10854     }
10855   return NULL;
10856 }
10857
10858 static const char *
10859 get_ppc64_symbol_other (unsigned int other)
10860 {
10861   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10862     {
10863       static char buf[32];
10864       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10865                 PPC64_LOCAL_ENTRY_OFFSET (other));
10866       return buf;
10867     }
10868   return NULL;
10869 }
10870
10871 static const char *
10872 get_symbol_other (unsigned int other)
10873 {
10874   const char * result = NULL;
10875   static char buff [32];
10876
10877   if (other == 0)
10878     return "";
10879
10880   switch (elf_header.e_machine)
10881     {
10882     case EM_MIPS:
10883       result = get_mips_symbol_other (other);
10884       break;
10885     case EM_IA_64:
10886       result = get_ia64_symbol_other (other);
10887       break;
10888     case EM_PPC64:
10889       result = get_ppc64_symbol_other (other);
10890       break;
10891     default:
10892       result = NULL;
10893       break;
10894     }
10895
10896   if (result)
10897     return result;
10898
10899   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10900   return buff;
10901 }
10902
10903 static const char *
10904 get_symbol_index_type (unsigned int type)
10905 {
10906   static char buff[32];
10907
10908   switch (type)
10909     {
10910     case SHN_UNDEF:     return "UND";
10911     case SHN_ABS:       return "ABS";
10912     case SHN_COMMON:    return "COM";
10913     default:
10914       if (type == SHN_IA_64_ANSI_COMMON
10915           && elf_header.e_machine == EM_IA_64
10916           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10917         return "ANSI_COM";
10918       else if ((elf_header.e_machine == EM_X86_64
10919                 || elf_header.e_machine == EM_L1OM
10920                 || elf_header.e_machine == EM_K1OM)
10921                && type == SHN_X86_64_LCOMMON)
10922         return "LARGE_COM";
10923       else if ((type == SHN_MIPS_SCOMMON
10924                 && elf_header.e_machine == EM_MIPS)
10925                || (type == SHN_TIC6X_SCOMMON
10926                    && elf_header.e_machine == EM_TI_C6000))
10927         return "SCOM";
10928       else if (type == SHN_MIPS_SUNDEFINED
10929                && elf_header.e_machine == EM_MIPS)
10930         return "SUND";
10931       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10932         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10933       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10934         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10935       else if (type >= SHN_LORESERVE)
10936         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10937       else if (type >= elf_header.e_shnum)
10938         sprintf (buff, _("bad section index[%3d]"), type);
10939       else
10940         sprintf (buff, "%3d", type);
10941       break;
10942     }
10943
10944   return buff;
10945 }
10946
10947 static bfd_vma *
10948 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10949 {
10950   unsigned char * e_data;
10951   bfd_vma * i_data;
10952
10953   /* If the size_t type is smaller than the bfd_size_type, eg because
10954      you are building a 32-bit tool on a 64-bit host, then make sure
10955      that when (number) is cast to (size_t) no information is lost.  */
10956   if (sizeof (size_t) < sizeof (bfd_size_type)
10957       && (bfd_size_type) ((size_t) number) != number)
10958     {
10959       error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10960                " elements of size %u\n"),
10961              number, ent_size);
10962       return NULL;
10963     }
10964
10965   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10966      attempting to allocate memory when the read is bound to fail.  */
10967   if (ent_size * number > current_file_size)
10968     {
10969       error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10970              number);
10971       return NULL;
10972     }
10973
10974   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10975   if (e_data == NULL)
10976     {
10977       error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10978              number);
10979       return NULL;
10980     }
10981
10982   if (fread (e_data, ent_size, (size_t) number, file) != number)
10983     {
10984       error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10985              number * ent_size);
10986       free (e_data);
10987       return NULL;
10988     }
10989
10990   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10991   if (i_data == NULL)
10992     {
10993       error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10994                " dynamic entries\n"),
10995              number);
10996       free (e_data);
10997       return NULL;
10998     }
10999
11000   while (number--)
11001     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11002
11003   free (e_data);
11004
11005   return i_data;
11006 }
11007
11008 static void
11009 print_dynamic_symbol (bfd_vma si, unsigned long hn)
11010 {
11011   Elf_Internal_Sym * psym;
11012   int n;
11013
11014   n = print_vma (si, DEC_5);
11015   if (n < 5)
11016     fputs (&"     "[n], stdout);
11017   printf (" %3lu: ", hn);
11018
11019   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11020     {
11021       printf (_("<No info available for dynamic symbol number %lu>\n"),
11022               (unsigned long) si);
11023       return;
11024     }
11025
11026   psym = dynamic_symbols + si;
11027   print_vma (psym->st_value, LONG_HEX);
11028   putchar (' ');
11029   print_vma (psym->st_size, DEC_5);
11030
11031   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11032   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11033
11034   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11035     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11036   else
11037     {
11038       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11039
11040       printf (" %-7s",  get_symbol_visibility (vis));
11041       /* Check to see if any other bits in the st_other field are set.
11042          Note - displaying this information disrupts the layout of the
11043          table being generated, but for the moment this case is very
11044          rare.  */
11045       if (psym->st_other ^ vis)
11046         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11047     }
11048
11049   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11050   if (VALID_DYNAMIC_NAME (psym->st_name))
11051     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11052   else
11053     printf (_(" <corrupt: %14ld>"), psym->st_name);
11054   putchar ('\n');
11055 }
11056
11057 static const char *
11058 get_symbol_version_string (FILE *                       file,
11059                            bfd_boolean                  is_dynsym,
11060                            const char *                 strtab,
11061                            unsigned long int            strtab_size,
11062                            unsigned int                 si,
11063                            Elf_Internal_Sym *           psym,
11064                            enum versioned_symbol_info * sym_info,
11065                            unsigned short *             vna_other)
11066 {
11067   unsigned char data[2];
11068   unsigned short vers_data;
11069   unsigned long offset;
11070
11071   if (!is_dynsym
11072       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11073     return NULL;
11074
11075   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11076                             sizeof data + si * sizeof (vers_data));
11077
11078   if (get_data (&data, file, offset + si * sizeof (vers_data),
11079                 sizeof (data), 1, _("version data")) == NULL)
11080     return NULL;
11081
11082   vers_data = byte_get (data, 2);
11083
11084   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11085     return NULL;
11086
11087   /* Usually we'd only see verdef for defined symbols, and verneed for
11088      undefined symbols.  However, symbols defined by the linker in
11089      .dynbss for variables copied from a shared library in order to
11090      avoid text relocations are defined yet have verneed.  We could
11091      use a heuristic to detect the special case, for example, check
11092      for verneed first on symbols defined in SHT_NOBITS sections, but
11093      it is simpler and more reliable to just look for both verdef and
11094      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11095
11096   if (psym->st_shndx != SHN_UNDEF
11097       && vers_data != 0x8001
11098       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11099     {
11100       Elf_Internal_Verdef ivd;
11101       Elf_Internal_Verdaux ivda;
11102       Elf_External_Verdaux evda;
11103       unsigned long off;
11104
11105       off = offset_from_vma (file,
11106                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11107                              sizeof (Elf_External_Verdef));
11108
11109       do
11110         {
11111           Elf_External_Verdef evd;
11112
11113           if (get_data (&evd, file, off, sizeof (evd), 1,
11114                         _("version def")) == NULL)
11115             {
11116               ivd.vd_ndx = 0;
11117               ivd.vd_aux = 0;
11118               ivd.vd_next = 0;
11119             }
11120           else
11121             {
11122               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11123               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11124               ivd.vd_next = BYTE_GET (evd.vd_next);
11125             }
11126
11127           off += ivd.vd_next;
11128         }
11129       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11130
11131       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11132         {
11133           off -= ivd.vd_next;
11134           off += ivd.vd_aux;
11135
11136           if (get_data (&evda, file, off, sizeof (evda), 1,
11137                         _("version def aux")) != NULL)
11138             {
11139               ivda.vda_name = BYTE_GET (evda.vda_name);
11140
11141               if (psym->st_name != ivda.vda_name)
11142                 {
11143                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11144                                ? symbol_hidden : symbol_public);
11145                   return (ivda.vda_name < strtab_size
11146                           ? strtab + ivda.vda_name : _("<corrupt>"));
11147                 }
11148             }
11149         }
11150     }
11151
11152   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11153     {
11154       Elf_External_Verneed evn;
11155       Elf_Internal_Verneed ivn;
11156       Elf_Internal_Vernaux ivna;
11157
11158       offset = offset_from_vma (file,
11159                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11160                                 sizeof evn);
11161       do
11162         {
11163           unsigned long vna_off;
11164
11165           if (get_data (&evn, file, offset, sizeof (evn), 1,
11166                         _("version need")) == NULL)
11167             {
11168               ivna.vna_next = 0;
11169               ivna.vna_other = 0;
11170               ivna.vna_name = 0;
11171               break;
11172             }
11173
11174           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11175           ivn.vn_next = BYTE_GET (evn.vn_next);
11176
11177           vna_off = offset + ivn.vn_aux;
11178
11179           do
11180             {
11181               Elf_External_Vernaux evna;
11182
11183               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11184                             _("version need aux (3)")) == NULL)
11185                 {
11186                   ivna.vna_next = 0;
11187                   ivna.vna_other = 0;
11188                   ivna.vna_name = 0;
11189                 }
11190               else
11191                 {
11192                   ivna.vna_other = BYTE_GET (evna.vna_other);
11193                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11194                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11195                 }
11196
11197               vna_off += ivna.vna_next;
11198             }
11199           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11200
11201           if (ivna.vna_other == vers_data)
11202             break;
11203
11204           offset += ivn.vn_next;
11205         }
11206       while (ivn.vn_next != 0);
11207
11208       if (ivna.vna_other == vers_data)
11209         {
11210           *sym_info = symbol_undefined;
11211           *vna_other = ivna.vna_other;
11212           return (ivna.vna_name < strtab_size
11213                   ? strtab + ivna.vna_name : _("<corrupt>"));
11214         }
11215     }
11216   return NULL;
11217 }
11218
11219 /* Dump the symbol table.  */
11220 static bfd_boolean
11221 process_symbol_table (FILE * file)
11222 {
11223   Elf_Internal_Shdr * section;
11224   bfd_size_type nbuckets = 0;
11225   bfd_size_type nchains = 0;
11226   bfd_vma * buckets = NULL;
11227   bfd_vma * chains = NULL;
11228   bfd_vma ngnubuckets = 0;
11229   bfd_vma * gnubuckets = NULL;
11230   bfd_vma * gnuchains = NULL;
11231   bfd_vma gnusymidx = 0;
11232   bfd_size_type ngnuchains = 0;
11233
11234   if (!do_syms && !do_dyn_syms && !do_histogram)
11235     return TRUE;
11236
11237   if (dynamic_info[DT_HASH]
11238       && (do_histogram
11239           || (do_using_dynamic
11240               && !do_dyn_syms
11241               && dynamic_strings != NULL)))
11242     {
11243       unsigned char nb[8];
11244       unsigned char nc[8];
11245       unsigned int hash_ent_size = 4;
11246
11247       if ((elf_header.e_machine == EM_ALPHA
11248            || elf_header.e_machine == EM_S390
11249            || elf_header.e_machine == EM_S390_OLD)
11250           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11251         hash_ent_size = 8;
11252
11253       if (fseek (file,
11254                  (archive_file_offset
11255                   + offset_from_vma (file, dynamic_info[DT_HASH],
11256                                      sizeof nb + sizeof nc)),
11257                  SEEK_SET))
11258         {
11259           error (_("Unable to seek to start of dynamic information\n"));
11260           goto no_hash;
11261         }
11262
11263       if (fread (nb, hash_ent_size, 1, file) != 1)
11264         {
11265           error (_("Failed to read in number of buckets\n"));
11266           goto no_hash;
11267         }
11268
11269       if (fread (nc, hash_ent_size, 1, file) != 1)
11270         {
11271           error (_("Failed to read in number of chains\n"));
11272           goto no_hash;
11273         }
11274
11275       nbuckets = byte_get (nb, hash_ent_size);
11276       nchains  = byte_get (nc, hash_ent_size);
11277
11278       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11279       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11280
11281     no_hash:
11282       if (buckets == NULL || chains == NULL)
11283         {
11284           if (do_using_dynamic)
11285             return FALSE;
11286           free (buckets);
11287           free (chains);
11288           buckets = NULL;
11289           chains = NULL;
11290           nbuckets = 0;
11291           nchains = 0;
11292         }
11293     }
11294
11295   if (dynamic_info_DT_GNU_HASH
11296       && (do_histogram
11297           || (do_using_dynamic
11298               && !do_dyn_syms
11299               && dynamic_strings != NULL)))
11300     {
11301       unsigned char nb[16];
11302       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11303       bfd_vma buckets_vma;
11304
11305       if (fseek (file,
11306                  (archive_file_offset
11307                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11308                                      sizeof nb)),
11309                  SEEK_SET))
11310         {
11311           error (_("Unable to seek to start of dynamic information\n"));
11312           goto no_gnu_hash;
11313         }
11314
11315       if (fread (nb, 16, 1, file) != 1)
11316         {
11317           error (_("Failed to read in number of buckets\n"));
11318           goto no_gnu_hash;
11319         }
11320
11321       ngnubuckets = byte_get (nb, 4);
11322       gnusymidx = byte_get (nb + 4, 4);
11323       bitmaskwords = byte_get (nb + 8, 4);
11324       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11325       if (is_32bit_elf)
11326         buckets_vma += bitmaskwords * 4;
11327       else
11328         buckets_vma += bitmaskwords * 8;
11329
11330       if (fseek (file,
11331                  (archive_file_offset
11332                   + offset_from_vma (file, buckets_vma, 4)),
11333                  SEEK_SET))
11334         {
11335           error (_("Unable to seek to start of dynamic information\n"));
11336           goto no_gnu_hash;
11337         }
11338
11339       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11340
11341       if (gnubuckets == NULL)
11342         goto no_gnu_hash;
11343
11344       for (i = 0; i < ngnubuckets; i++)
11345         if (gnubuckets[i] != 0)
11346           {
11347             if (gnubuckets[i] < gnusymidx)
11348               return FALSE;
11349
11350             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11351               maxchain = gnubuckets[i];
11352           }
11353
11354       if (maxchain == 0xffffffff)
11355         goto no_gnu_hash;
11356
11357       maxchain -= gnusymidx;
11358
11359       if (fseek (file,
11360                  (archive_file_offset
11361                   + offset_from_vma (file, buckets_vma
11362                                            + 4 * (ngnubuckets + maxchain), 4)),
11363                  SEEK_SET))
11364         {
11365           error (_("Unable to seek to start of dynamic information\n"));
11366           goto no_gnu_hash;
11367         }
11368
11369       do
11370         {
11371           if (fread (nb, 4, 1, file) != 1)
11372             {
11373               error (_("Failed to determine last chain length\n"));
11374               goto no_gnu_hash;
11375             }
11376
11377           if (maxchain + 1 == 0)
11378             goto no_gnu_hash;
11379
11380           ++maxchain;
11381         }
11382       while ((byte_get (nb, 4) & 1) == 0);
11383
11384       if (fseek (file,
11385                  (archive_file_offset
11386                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11387                  SEEK_SET))
11388         {
11389           error (_("Unable to seek to start of dynamic information\n"));
11390           goto no_gnu_hash;
11391         }
11392
11393       gnuchains = get_dynamic_data (file, maxchain, 4);
11394       ngnuchains = maxchain;
11395
11396     no_gnu_hash:
11397       if (gnuchains == NULL)
11398         {
11399           free (gnubuckets);
11400           gnubuckets = NULL;
11401           ngnubuckets = 0;
11402           if (do_using_dynamic)
11403             return FALSE;
11404         }
11405     }
11406
11407   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11408       && do_syms
11409       && do_using_dynamic
11410       && dynamic_strings != NULL
11411       && dynamic_symbols != NULL)
11412     {
11413       unsigned long hn;
11414
11415       if (dynamic_info[DT_HASH])
11416         {
11417           bfd_vma si;
11418
11419           printf (_("\nSymbol table for image:\n"));
11420           if (is_32bit_elf)
11421             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11422           else
11423             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11424
11425           for (hn = 0; hn < nbuckets; hn++)
11426             {
11427               if (! buckets[hn])
11428                 continue;
11429
11430               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11431                 print_dynamic_symbol (si, hn);
11432             }
11433         }
11434
11435       if (dynamic_info_DT_GNU_HASH)
11436         {
11437           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11438           if (is_32bit_elf)
11439             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11440           else
11441             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11442
11443           for (hn = 0; hn < ngnubuckets; ++hn)
11444             if (gnubuckets[hn] != 0)
11445               {
11446                 bfd_vma si = gnubuckets[hn];
11447                 bfd_vma off = si - gnusymidx;
11448
11449                 do
11450                   {
11451                     print_dynamic_symbol (si, hn);
11452                     si++;
11453                   }
11454                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11455               }
11456         }
11457     }
11458   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11459            && section_headers != NULL)
11460     {
11461       unsigned int i;
11462
11463       for (i = 0, section = section_headers;
11464            i < elf_header.e_shnum;
11465            i++, section++)
11466         {
11467           unsigned int si;
11468           char * strtab = NULL;
11469           unsigned long int strtab_size = 0;
11470           Elf_Internal_Sym * symtab;
11471           Elf_Internal_Sym * psym;
11472           unsigned long num_syms;
11473
11474           if ((section->sh_type != SHT_SYMTAB
11475                && section->sh_type != SHT_DYNSYM)
11476               || (!do_syms
11477                   && section->sh_type == SHT_SYMTAB))
11478             continue;
11479
11480           if (section->sh_entsize == 0)
11481             {
11482               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11483                       printable_section_name (section));
11484               continue;
11485             }
11486
11487           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11488                   printable_section_name (section),
11489                   (unsigned long) (section->sh_size / section->sh_entsize));
11490
11491           if (is_32bit_elf)
11492             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11493           else
11494             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11495
11496           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11497           if (symtab == NULL)
11498             continue;
11499
11500           if (section->sh_link == elf_header.e_shstrndx)
11501             {
11502               strtab = string_table;
11503               strtab_size = string_table_length;
11504             }
11505           else if (section->sh_link < elf_header.e_shnum)
11506             {
11507               Elf_Internal_Shdr * string_sec;
11508
11509               string_sec = section_headers + section->sh_link;
11510
11511               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11512                                           1, string_sec->sh_size,
11513                                           _("string table"));
11514               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11515             }
11516
11517           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11518             {
11519               const char *version_string;
11520               enum versioned_symbol_info sym_info;
11521               unsigned short vna_other;
11522
11523               printf ("%6d: ", si);
11524               print_vma (psym->st_value, LONG_HEX);
11525               putchar (' ');
11526               print_vma (psym->st_size, DEC_5);
11527               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11528               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11529               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11530                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11531               else
11532                 {
11533                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11534
11535                   printf (" %-7s", get_symbol_visibility (vis));
11536                   /* Check to see if any other bits in the st_other field are set.
11537                      Note - displaying this information disrupts the layout of the
11538                      table being generated, but for the moment this case is very rare.  */
11539                   if (psym->st_other ^ vis)
11540                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11541                 }
11542               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11543               print_symbol (25, psym->st_name < strtab_size
11544                             ? strtab + psym->st_name : _("<corrupt>"));
11545
11546               version_string
11547                 = get_symbol_version_string (file,
11548                                              section->sh_type == SHT_DYNSYM,
11549                                              strtab, strtab_size, si,
11550                                              psym, &sym_info, &vna_other);
11551               if (version_string)
11552                 {
11553                   if (sym_info == symbol_undefined)
11554                     printf ("@%s (%d)", version_string, vna_other);
11555                   else
11556                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11557                             version_string);
11558                 }
11559
11560               putchar ('\n');
11561
11562               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11563                   && si >= section->sh_info
11564                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11565                   && elf_header.e_machine != EM_MIPS
11566                   /* Solaris binaries have been found to violate this requirement as
11567                      well.  Not sure if this is a bug or an ABI requirement.  */
11568                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11569                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11570                       si, printable_section_name (section), section->sh_info);
11571             }
11572
11573           free (symtab);
11574           if (strtab != string_table)
11575             free (strtab);
11576         }
11577     }
11578   else if (do_syms)
11579     printf
11580       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11581
11582   if (do_histogram && buckets != NULL)
11583     {
11584       unsigned long * lengths;
11585       unsigned long * counts;
11586       unsigned long hn;
11587       bfd_vma si;
11588       unsigned long maxlength = 0;
11589       unsigned long nzero_counts = 0;
11590       unsigned long nsyms = 0;
11591       unsigned long chained;
11592
11593       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11594               (unsigned long) nbuckets);
11595
11596       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11597       if (lengths == NULL)
11598         {
11599           error (_("Out of memory allocating space for histogram buckets\n"));
11600           return FALSE;
11601         }
11602
11603       printf (_(" Length  Number     %% of total  Coverage\n"));
11604       for (hn = 0; hn < nbuckets; ++hn)
11605         {
11606           for (si = buckets[hn], chained = 0;
11607                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11608                si = chains[si], ++chained)
11609             {
11610               ++nsyms;
11611               if (maxlength < ++lengths[hn])
11612                 ++maxlength;
11613             }
11614
11615             /* PR binutils/17531: A corrupt binary could contain broken
11616                histogram data.  Do not go into an infinite loop trying
11617                to process it.  */
11618             if (chained > nchains)
11619               {
11620                 error (_("histogram chain is corrupt\n"));
11621                 break;
11622               }
11623         }
11624
11625       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11626       if (counts == NULL)
11627         {
11628           free (lengths);
11629           error (_("Out of memory allocating space for histogram counts\n"));
11630           return FALSE;
11631         }
11632
11633       for (hn = 0; hn < nbuckets; ++hn)
11634         ++counts[lengths[hn]];
11635
11636       if (nbuckets > 0)
11637         {
11638           unsigned long i;
11639           printf ("      0  %-10lu (%5.1f%%)\n",
11640                   counts[0], (counts[0] * 100.0) / nbuckets);
11641           for (i = 1; i <= maxlength; ++i)
11642             {
11643               nzero_counts += counts[i] * i;
11644               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11645                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11646                       (nzero_counts * 100.0) / nsyms);
11647             }
11648         }
11649
11650       free (counts);
11651       free (lengths);
11652     }
11653
11654   if (buckets != NULL)
11655     {
11656       free (buckets);
11657       free (chains);
11658     }
11659
11660   if (do_histogram && gnubuckets != NULL)
11661     {
11662       unsigned long * lengths;
11663       unsigned long * counts;
11664       unsigned long hn;
11665       unsigned long maxlength = 0;
11666       unsigned long nzero_counts = 0;
11667       unsigned long nsyms = 0;
11668
11669       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11670               (unsigned long) ngnubuckets);
11671
11672       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11673       if (lengths == NULL)
11674         {
11675           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11676           return FALSE;
11677         }
11678
11679       printf (_(" Length  Number     %% of total  Coverage\n"));
11680
11681       for (hn = 0; hn < ngnubuckets; ++hn)
11682         if (gnubuckets[hn] != 0)
11683           {
11684             bfd_vma off, length = 1;
11685
11686             for (off = gnubuckets[hn] - gnusymidx;
11687                  /* PR 17531 file: 010-77222-0.004.  */
11688                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11689                  ++off)
11690               ++length;
11691             lengths[hn] = length;
11692             if (length > maxlength)
11693               maxlength = length;
11694             nsyms += length;
11695           }
11696
11697       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11698       if (counts == NULL)
11699         {
11700           free (lengths);
11701           error (_("Out of memory allocating space for gnu histogram counts\n"));
11702           return FALSE;
11703         }
11704
11705       for (hn = 0; hn < ngnubuckets; ++hn)
11706         ++counts[lengths[hn]];
11707
11708       if (ngnubuckets > 0)
11709         {
11710           unsigned long j;
11711           printf ("      0  %-10lu (%5.1f%%)\n",
11712                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11713           for (j = 1; j <= maxlength; ++j)
11714             {
11715               nzero_counts += counts[j] * j;
11716               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11717                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11718                       (nzero_counts * 100.0) / nsyms);
11719             }
11720         }
11721
11722       free (counts);
11723       free (lengths);
11724       free (gnubuckets);
11725       free (gnuchains);
11726     }
11727
11728   return TRUE;
11729 }
11730
11731 static bfd_boolean
11732 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11733 {
11734   unsigned int i;
11735
11736   if (dynamic_syminfo == NULL
11737       || !do_dynamic)
11738     /* No syminfo, this is ok.  */
11739     return TRUE;
11740
11741   /* There better should be a dynamic symbol section.  */
11742   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11743     return FALSE;
11744
11745   if (dynamic_addr)
11746     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11747             dynamic_syminfo_offset, dynamic_syminfo_nent);
11748
11749   printf (_(" Num: Name                           BoundTo     Flags\n"));
11750   for (i = 0; i < dynamic_syminfo_nent; ++i)
11751     {
11752       unsigned short int flags = dynamic_syminfo[i].si_flags;
11753
11754       printf ("%4d: ", i);
11755       if (i >= num_dynamic_syms)
11756         printf (_("<corrupt index>"));
11757       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11758         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11759       else
11760         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11761       putchar (' ');
11762
11763       switch (dynamic_syminfo[i].si_boundto)
11764         {
11765         case SYMINFO_BT_SELF:
11766           fputs ("SELF       ", stdout);
11767           break;
11768         case SYMINFO_BT_PARENT:
11769           fputs ("PARENT     ", stdout);
11770           break;
11771         default:
11772           if (dynamic_syminfo[i].si_boundto > 0
11773               && dynamic_syminfo[i].si_boundto < dynamic_nent
11774               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11775             {
11776               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11777               putchar (' ' );
11778             }
11779           else
11780             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11781           break;
11782         }
11783
11784       if (flags & SYMINFO_FLG_DIRECT)
11785         printf (" DIRECT");
11786       if (flags & SYMINFO_FLG_PASSTHRU)
11787         printf (" PASSTHRU");
11788       if (flags & SYMINFO_FLG_COPY)
11789         printf (" COPY");
11790       if (flags & SYMINFO_FLG_LAZYLOAD)
11791         printf (" LAZYLOAD");
11792
11793       puts ("");
11794     }
11795
11796   return TRUE;
11797 }
11798
11799 #define IN_RANGE(START,END,ADDR,OFF)            \
11800   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11801
11802 /* Check to see if the given reloc needs to be handled in a target specific
11803    manner.  If so then process the reloc and return TRUE otherwise return
11804    FALSE.
11805
11806    If called with reloc == NULL, then this is a signal that reloc processing
11807    for the current section has finished, and any saved state should be
11808    discarded.  */
11809
11810 static bfd_boolean
11811 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11812                                 unsigned char *     start,
11813                                 unsigned char *     end,
11814                                 Elf_Internal_Sym *  symtab,
11815                                 unsigned long       num_syms)
11816 {
11817   unsigned int reloc_type = 0;
11818   unsigned long sym_index = 0;
11819
11820   if (reloc)
11821     {
11822       reloc_type = get_reloc_type (reloc->r_info);
11823       sym_index = get_reloc_symindex (reloc->r_info);
11824     }
11825
11826   switch (elf_header.e_machine)
11827     {
11828     case EM_MSP430:
11829     case EM_MSP430_OLD:
11830       {
11831         static Elf_Internal_Sym * saved_sym = NULL;
11832
11833         if (reloc == NULL)
11834           {
11835             saved_sym = NULL;
11836             return TRUE;
11837           }
11838
11839         switch (reloc_type)
11840           {
11841           case 10: /* R_MSP430_SYM_DIFF */
11842             if (uses_msp430x_relocs ())
11843               break;
11844             /* Fall through.  */
11845           case 21: /* R_MSP430X_SYM_DIFF */
11846             /* PR 21139.  */
11847             if (sym_index >= num_syms)
11848               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11849                      sym_index);
11850             else
11851               saved_sym = symtab + sym_index;
11852             return TRUE;
11853
11854           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11855           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11856             goto handle_sym_diff;
11857
11858           case 5: /* R_MSP430_16_BYTE */
11859           case 9: /* R_MSP430_8 */
11860             if (uses_msp430x_relocs ())
11861               break;
11862             goto handle_sym_diff;
11863
11864           case 2: /* R_MSP430_ABS16 */
11865           case 15: /* R_MSP430X_ABS16 */
11866             if (! uses_msp430x_relocs ())
11867               break;
11868             goto handle_sym_diff;
11869
11870           handle_sym_diff:
11871             if (saved_sym != NULL)
11872               {
11873                 int reloc_size = reloc_type == 1 ? 4 : 2;
11874                 bfd_vma value;
11875
11876                 if (sym_index >= num_syms)
11877                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11878                          sym_index);
11879                 else
11880                   {
11881                     value = reloc->r_addend + (symtab[sym_index].st_value
11882                                                - saved_sym->st_value);
11883
11884                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11885                       byte_put (start + reloc->r_offset, value, reloc_size);
11886                     else
11887                       /* PR 21137 */
11888                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11889                              (long) reloc->r_offset);
11890                   }
11891
11892                 saved_sym = NULL;
11893                 return TRUE;
11894               }
11895             break;
11896
11897           default:
11898             if (saved_sym != NULL)
11899               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11900             break;
11901           }
11902         break;
11903       }
11904
11905     case EM_MN10300:
11906     case EM_CYGNUS_MN10300:
11907       {
11908         static Elf_Internal_Sym * saved_sym = NULL;
11909
11910         if (reloc == NULL)
11911           {
11912             saved_sym = NULL;
11913             return TRUE;
11914           }
11915
11916         switch (reloc_type)
11917           {
11918           case 34: /* R_MN10300_ALIGN */
11919             return TRUE;
11920           case 33: /* R_MN10300_SYM_DIFF */
11921             if (sym_index >= num_syms)
11922               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11923                      sym_index);
11924             else
11925               saved_sym = symtab + sym_index;
11926             return TRUE;
11927
11928           case 1: /* R_MN10300_32 */
11929           case 2: /* R_MN10300_16 */
11930             if (saved_sym != NULL)
11931               {
11932                 int reloc_size = reloc_type == 1 ? 4 : 2;
11933                 bfd_vma value;
11934
11935                 if (sym_index >= num_syms)
11936                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11937                          sym_index);
11938                 else
11939                   {
11940                     value = reloc->r_addend + (symtab[sym_index].st_value
11941                                                - saved_sym->st_value);
11942
11943                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11944                       byte_put (start + reloc->r_offset, value, reloc_size);
11945                     else
11946                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11947                              (long) reloc->r_offset);
11948                   }
11949
11950                 saved_sym = NULL;
11951                 return TRUE;
11952               }
11953             break;
11954           default:
11955             if (saved_sym != NULL)
11956               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11957             break;
11958           }
11959         break;
11960       }
11961
11962     case EM_RL78:
11963       {
11964         static bfd_vma saved_sym1 = 0;
11965         static bfd_vma saved_sym2 = 0;
11966         static bfd_vma value;
11967
11968         if (reloc == NULL)
11969           {
11970             saved_sym1 = saved_sym2 = 0;
11971             return TRUE;
11972           }
11973
11974         switch (reloc_type)
11975           {
11976           case 0x80: /* R_RL78_SYM.  */
11977             saved_sym1 = saved_sym2;
11978             if (sym_index >= num_syms)
11979               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11980                      sym_index);
11981             else
11982               {
11983                 saved_sym2 = symtab[sym_index].st_value;
11984                 saved_sym2 += reloc->r_addend;
11985               }
11986             return TRUE;
11987
11988           case 0x83: /* R_RL78_OPsub.  */
11989             value = saved_sym1 - saved_sym2;
11990             saved_sym2 = saved_sym1 = 0;
11991             return TRUE;
11992             break;
11993
11994           case 0x41: /* R_RL78_ABS32.  */
11995             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11996               byte_put (start + reloc->r_offset, value, 4);
11997             else
11998               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11999                      (long) reloc->r_offset);
12000             value = 0;
12001             return TRUE;
12002
12003           case 0x43: /* R_RL78_ABS16.  */
12004             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12005               byte_put (start + reloc->r_offset, value, 2);
12006             else
12007               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12008                      (long) reloc->r_offset);
12009             value = 0;
12010             return TRUE;
12011
12012           default:
12013             break;
12014           }
12015         break;
12016       }
12017     }
12018
12019   return FALSE;
12020 }
12021
12022 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12023    DWARF debug sections.  This is a target specific test.  Note - we do not
12024    go through the whole including-target-headers-multiple-times route, (as
12025    we have already done with <elf/h8.h>) because this would become very
12026    messy and even then this function would have to contain target specific
12027    information (the names of the relocs instead of their numeric values).
12028    FIXME: This is not the correct way to solve this problem.  The proper way
12029    is to have target specific reloc sizing and typing functions created by
12030    the reloc-macros.h header, in the same way that it already creates the
12031    reloc naming functions.  */
12032
12033 static bfd_boolean
12034 is_32bit_abs_reloc (unsigned int reloc_type)
12035 {
12036   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12037   switch (elf_header.e_machine)
12038     {
12039     case EM_386:
12040     case EM_IAMCU:
12041       return reloc_type == 1; /* R_386_32.  */
12042     case EM_68K:
12043       return reloc_type == 1; /* R_68K_32.  */
12044     case EM_860:
12045       return reloc_type == 1; /* R_860_32.  */
12046     case EM_960:
12047       return reloc_type == 2; /* R_960_32.  */
12048     case EM_AARCH64:
12049       return (reloc_type == 258
12050               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12051     case EM_ADAPTEVA_EPIPHANY:
12052       return reloc_type == 3;
12053     case EM_ALPHA:
12054       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12055     case EM_ARC:
12056       return reloc_type == 1; /* R_ARC_32.  */
12057     case EM_ARC_COMPACT:
12058     case EM_ARC_COMPACT2:
12059       return reloc_type == 4; /* R_ARC_32.  */
12060     case EM_ARM:
12061       return reloc_type == 2; /* R_ARM_ABS32 */
12062     case EM_AVR_OLD:
12063     case EM_AVR:
12064       return reloc_type == 1;
12065     case EM_BLACKFIN:
12066       return reloc_type == 0x12; /* R_byte4_data.  */
12067     case EM_CRIS:
12068       return reloc_type == 3; /* R_CRIS_32.  */
12069     case EM_CR16:
12070       return reloc_type == 3; /* R_CR16_NUM32.  */
12071     case EM_CRX:
12072       return reloc_type == 15; /* R_CRX_NUM32.  */
12073     case EM_CYGNUS_FRV:
12074       return reloc_type == 1;
12075     case EM_CYGNUS_D10V:
12076     case EM_D10V:
12077       return reloc_type == 6; /* R_D10V_32.  */
12078     case EM_CYGNUS_D30V:
12079     case EM_D30V:
12080       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12081     case EM_DLX:
12082       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12083     case EM_CYGNUS_FR30:
12084     case EM_FR30:
12085       return reloc_type == 3; /* R_FR30_32.  */
12086     case EM_FT32:
12087       return reloc_type == 1; /* R_FT32_32.  */
12088     case EM_H8S:
12089     case EM_H8_300:
12090     case EM_H8_300H:
12091       return reloc_type == 1; /* R_H8_DIR32.  */
12092     case EM_IA_64:
12093       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12094               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12095               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12096               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12097     case EM_IP2K_OLD:
12098     case EM_IP2K:
12099       return reloc_type == 2; /* R_IP2K_32.  */
12100     case EM_IQ2000:
12101       return reloc_type == 2; /* R_IQ2000_32.  */
12102     case EM_LATTICEMICO32:
12103       return reloc_type == 3; /* R_LM32_32.  */
12104     case EM_M32C_OLD:
12105     case EM_M32C:
12106       return reloc_type == 3; /* R_M32C_32.  */
12107     case EM_M32R:
12108       return reloc_type == 34; /* R_M32R_32_RELA.  */
12109     case EM_68HC11:
12110     case EM_68HC12:
12111       return reloc_type == 6; /* R_M68HC11_32.  */
12112     case EM_MCORE:
12113       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12114     case EM_CYGNUS_MEP:
12115       return reloc_type == 4; /* R_MEP_32.  */
12116     case EM_METAG:
12117       return reloc_type == 2; /* R_METAG_ADDR32.  */
12118     case EM_MICROBLAZE:
12119       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12120     case EM_MIPS:
12121       return reloc_type == 2; /* R_MIPS_32.  */
12122     case EM_MMIX:
12123       return reloc_type == 4; /* R_MMIX_32.  */
12124     case EM_CYGNUS_MN10200:
12125     case EM_MN10200:
12126       return reloc_type == 1; /* R_MN10200_32.  */
12127     case EM_CYGNUS_MN10300:
12128     case EM_MN10300:
12129       return reloc_type == 1; /* R_MN10300_32.  */
12130     case EM_MOXIE:
12131       return reloc_type == 1; /* R_MOXIE_32.  */
12132     case EM_MSP430_OLD:
12133     case EM_MSP430:
12134       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12135     case EM_MT:
12136       return reloc_type == 2; /* R_MT_32.  */
12137     case EM_NDS32:
12138       return reloc_type == 20; /* R_NDS32_RELA.  */
12139     case EM_ALTERA_NIOS2:
12140       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12141     case EM_NIOS32:
12142       return reloc_type == 1; /* R_NIOS_32.  */
12143     case EM_OR1K:
12144       return reloc_type == 1; /* R_OR1K_32.  */
12145     case EM_PARISC:
12146       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12147               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12148     case EM_PJ:
12149     case EM_PJ_OLD:
12150       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12151     case EM_PPC64:
12152       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12153     case EM_PPC:
12154       return reloc_type == 1; /* R_PPC_ADDR32.  */
12155     case EM_TI_PRU:
12156       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12157     case EM_RISCV:
12158       return reloc_type == 1; /* R_RISCV_32.  */
12159     case EM_RL78:
12160       return reloc_type == 1; /* R_RL78_DIR32.  */
12161     case EM_RX:
12162       return reloc_type == 1; /* R_RX_DIR32.  */
12163     case EM_S370:
12164       return reloc_type == 1; /* R_I370_ADDR31.  */
12165     case EM_S390_OLD:
12166     case EM_S390:
12167       return reloc_type == 4; /* R_S390_32.  */
12168     case EM_SCORE:
12169       return reloc_type == 8; /* R_SCORE_ABS32.  */
12170     case EM_SH:
12171       return reloc_type == 1; /* R_SH_DIR32.  */
12172     case EM_SPARC32PLUS:
12173     case EM_SPARCV9:
12174     case EM_SPARC:
12175       return reloc_type == 3 /* R_SPARC_32.  */
12176         || reloc_type == 23; /* R_SPARC_UA32.  */
12177     case EM_SPU:
12178       return reloc_type == 6; /* R_SPU_ADDR32 */
12179     case EM_TI_C6000:
12180       return reloc_type == 1; /* R_C6000_ABS32.  */
12181     case EM_TILEGX:
12182       return reloc_type == 2; /* R_TILEGX_32.  */
12183     case EM_TILEPRO:
12184       return reloc_type == 1; /* R_TILEPRO_32.  */
12185     case EM_CYGNUS_V850:
12186     case EM_V850:
12187       return reloc_type == 6; /* R_V850_ABS32.  */
12188     case EM_V800:
12189       return reloc_type == 0x33; /* R_V810_WORD.  */
12190     case EM_VAX:
12191       return reloc_type == 1; /* R_VAX_32.  */
12192     case EM_VISIUM:
12193       return reloc_type == 3;  /* R_VISIUM_32. */
12194     case EM_WEBASSEMBLY:
12195       return reloc_type == 1;  /* R_WASM32_32.  */
12196     case EM_X86_64:
12197     case EM_L1OM:
12198     case EM_K1OM:
12199       return reloc_type == 10; /* R_X86_64_32.  */
12200     case EM_XC16X:
12201     case EM_C166:
12202       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12203     case EM_XGATE:
12204       return reloc_type == 4; /* R_XGATE_32.  */
12205     case EM_XSTORMY16:
12206       return reloc_type == 1; /* R_XSTROMY16_32.  */
12207     case EM_XTENSA_OLD:
12208     case EM_XTENSA:
12209       return reloc_type == 1; /* R_XTENSA_32.  */
12210     default:
12211       {
12212         static unsigned int prev_warn = 0;
12213
12214         /* Avoid repeating the same warning multiple times.  */
12215         if (prev_warn != elf_header.e_machine)
12216           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12217                  elf_header.e_machine);
12218         prev_warn = elf_header.e_machine;
12219         return FALSE;
12220       }
12221     }
12222 }
12223
12224 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12225    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12226
12227 static bfd_boolean
12228 is_32bit_pcrel_reloc (unsigned int reloc_type)
12229 {
12230   switch (elf_header.e_machine)
12231   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12232     {
12233     case EM_386:
12234     case EM_IAMCU:
12235       return reloc_type == 2;  /* R_386_PC32.  */
12236     case EM_68K:
12237       return reloc_type == 4;  /* R_68K_PC32.  */
12238     case EM_AARCH64:
12239       return reloc_type == 261; /* R_AARCH64_PREL32 */
12240     case EM_ADAPTEVA_EPIPHANY:
12241       return reloc_type == 6;
12242     case EM_ALPHA:
12243       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12244     case EM_ARC_COMPACT:
12245     case EM_ARC_COMPACT2:
12246       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12247     case EM_ARM:
12248       return reloc_type == 3;  /* R_ARM_REL32 */
12249     case EM_AVR_OLD:
12250     case EM_AVR:
12251       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12252     case EM_MICROBLAZE:
12253       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12254     case EM_OR1K:
12255       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12256     case EM_PARISC:
12257       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12258     case EM_PPC:
12259       return reloc_type == 26; /* R_PPC_REL32.  */
12260     case EM_PPC64:
12261       return reloc_type == 26; /* R_PPC64_REL32.  */
12262     case EM_S390_OLD:
12263     case EM_S390:
12264       return reloc_type == 5;  /* R_390_PC32.  */
12265     case EM_SH:
12266       return reloc_type == 2;  /* R_SH_REL32.  */
12267     case EM_SPARC32PLUS:
12268     case EM_SPARCV9:
12269     case EM_SPARC:
12270       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12271     case EM_SPU:
12272       return reloc_type == 13; /* R_SPU_REL32.  */
12273     case EM_TILEGX:
12274       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12275     case EM_TILEPRO:
12276       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12277     case EM_VISIUM:
12278       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12279     case EM_X86_64:
12280     case EM_L1OM:
12281     case EM_K1OM:
12282       return reloc_type == 2;  /* R_X86_64_PC32.  */
12283     case EM_XTENSA_OLD:
12284     case EM_XTENSA:
12285       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12286     default:
12287       /* Do not abort or issue an error message here.  Not all targets use
12288          pc-relative 32-bit relocs in their DWARF debug information and we
12289          have already tested for target coverage in is_32bit_abs_reloc.  A
12290          more helpful warning message will be generated by apply_relocations
12291          anyway, so just return.  */
12292       return FALSE;
12293     }
12294 }
12295
12296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12297    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12298
12299 static bfd_boolean
12300 is_64bit_abs_reloc (unsigned int reloc_type)
12301 {
12302   switch (elf_header.e_machine)
12303     {
12304     case EM_AARCH64:
12305       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12306     case EM_ALPHA:
12307       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12308     case EM_IA_64:
12309       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12310               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12311     case EM_PARISC:
12312       return reloc_type == 80; /* R_PARISC_DIR64.  */
12313     case EM_PPC64:
12314       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12315     case EM_RISCV:
12316       return reloc_type == 2; /* R_RISCV_64.  */
12317     case EM_SPARC32PLUS:
12318     case EM_SPARCV9:
12319     case EM_SPARC:
12320       return reloc_type == 32 /* R_SPARC_64.  */
12321         || reloc_type == 54; /* R_SPARC_UA64.  */
12322     case EM_X86_64:
12323     case EM_L1OM:
12324     case EM_K1OM:
12325       return reloc_type == 1; /* R_X86_64_64.  */
12326     case EM_S390_OLD:
12327     case EM_S390:
12328       return reloc_type == 22;  /* R_S390_64.  */
12329     case EM_TILEGX:
12330       return reloc_type == 1; /* R_TILEGX_64.  */
12331     case EM_MIPS:
12332       return reloc_type == 18;  /* R_MIPS_64.  */
12333     default:
12334       return FALSE;
12335     }
12336 }
12337
12338 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12339    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12340
12341 static bfd_boolean
12342 is_64bit_pcrel_reloc (unsigned int reloc_type)
12343 {
12344   switch (elf_header.e_machine)
12345     {
12346     case EM_AARCH64:
12347       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12348     case EM_ALPHA:
12349       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12350     case EM_IA_64:
12351       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12352               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12353     case EM_PARISC:
12354       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12355     case EM_PPC64:
12356       return reloc_type == 44; /* R_PPC64_REL64.  */
12357     case EM_SPARC32PLUS:
12358     case EM_SPARCV9:
12359     case EM_SPARC:
12360       return reloc_type == 46; /* R_SPARC_DISP64.  */
12361     case EM_X86_64:
12362     case EM_L1OM:
12363     case EM_K1OM:
12364       return reloc_type == 24; /* R_X86_64_PC64.  */
12365     case EM_S390_OLD:
12366     case EM_S390:
12367       return reloc_type == 23;  /* R_S390_PC64.  */
12368     case EM_TILEGX:
12369       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12370     default:
12371       return FALSE;
12372     }
12373 }
12374
12375 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12376    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12377
12378 static bfd_boolean
12379 is_24bit_abs_reloc (unsigned int reloc_type)
12380 {
12381   switch (elf_header.e_machine)
12382     {
12383     case EM_CYGNUS_MN10200:
12384     case EM_MN10200:
12385       return reloc_type == 4; /* R_MN10200_24.  */
12386     case EM_FT32:
12387       return reloc_type == 5; /* R_FT32_20.  */
12388     default:
12389       return FALSE;
12390     }
12391 }
12392
12393 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12394    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12395
12396 static bfd_boolean
12397 is_16bit_abs_reloc (unsigned int reloc_type)
12398 {
12399   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12400   switch (elf_header.e_machine)
12401     {
12402     case EM_ARC:
12403     case EM_ARC_COMPACT:
12404     case EM_ARC_COMPACT2:
12405       return reloc_type == 2; /* R_ARC_16.  */
12406     case EM_ADAPTEVA_EPIPHANY:
12407       return reloc_type == 5;
12408     case EM_AVR_OLD:
12409     case EM_AVR:
12410       return reloc_type == 4; /* R_AVR_16.  */
12411     case EM_CYGNUS_D10V:
12412     case EM_D10V:
12413       return reloc_type == 3; /* R_D10V_16.  */
12414     case EM_H8S:
12415     case EM_H8_300:
12416     case EM_H8_300H:
12417       return reloc_type == R_H8_DIR16;
12418     case EM_IP2K_OLD:
12419     case EM_IP2K:
12420       return reloc_type == 1; /* R_IP2K_16.  */
12421     case EM_M32C_OLD:
12422     case EM_M32C:
12423       return reloc_type == 1; /* R_M32C_16 */
12424     case EM_CYGNUS_MN10200:
12425     case EM_MN10200:
12426       return reloc_type == 2; /* R_MN10200_16.  */
12427     case EM_CYGNUS_MN10300:
12428     case EM_MN10300:
12429       return reloc_type == 2; /* R_MN10300_16.  */
12430     case EM_MSP430:
12431       if (uses_msp430x_relocs ())
12432         return reloc_type == 2; /* R_MSP430_ABS16.  */
12433       /* Fall through.  */
12434     case EM_MSP430_OLD:
12435       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12436     case EM_NDS32:
12437       return reloc_type == 19; /* R_NDS32_RELA.  */
12438     case EM_ALTERA_NIOS2:
12439       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12440     case EM_NIOS32:
12441       return reloc_type == 9; /* R_NIOS_16.  */
12442     case EM_OR1K:
12443       return reloc_type == 2; /* R_OR1K_16.  */
12444     case EM_TI_PRU:
12445       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12446     case EM_TI_C6000:
12447       return reloc_type == 2; /* R_C6000_ABS16.  */
12448     case EM_VISIUM:
12449       return reloc_type == 2; /* R_VISIUM_16. */
12450     case EM_XC16X:
12451     case EM_C166:
12452       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12453     case EM_XGATE:
12454       return reloc_type == 3; /* R_XGATE_16.  */
12455     default:
12456       return FALSE;
12457     }
12458 }
12459
12460 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12461    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12462
12463 static bfd_boolean
12464 is_none_reloc (unsigned int reloc_type)
12465 {
12466   switch (elf_header.e_machine)
12467     {
12468     case EM_386:     /* R_386_NONE.  */
12469     case EM_68K:     /* R_68K_NONE.  */
12470     case EM_ADAPTEVA_EPIPHANY:
12471     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12472     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12473     case EM_ARC:     /* R_ARC_NONE.  */
12474     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12475     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12476     case EM_ARM:     /* R_ARM_NONE.  */
12477     case EM_C166:    /* R_XC16X_NONE.  */
12478     case EM_CRIS:    /* R_CRIS_NONE.  */
12479     case EM_FT32:    /* R_FT32_NONE.  */
12480     case EM_IA_64:   /* R_IA64_NONE.  */
12481     case EM_K1OM:    /* R_X86_64_NONE.  */
12482     case EM_L1OM:    /* R_X86_64_NONE.  */
12483     case EM_M32R:    /* R_M32R_NONE.  */
12484     case EM_MIPS:    /* R_MIPS_NONE.  */
12485     case EM_MN10300: /* R_MN10300_NONE.  */
12486     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12487     case EM_NIOS32:  /* R_NIOS_NONE.  */
12488     case EM_OR1K:    /* R_OR1K_NONE. */
12489     case EM_PARISC:  /* R_PARISC_NONE.  */
12490     case EM_PPC64:   /* R_PPC64_NONE.  */
12491     case EM_PPC:     /* R_PPC_NONE.  */
12492     case EM_RISCV:   /* R_RISCV_NONE.  */
12493     case EM_S390:    /* R_390_NONE.  */
12494     case EM_S390_OLD:
12495     case EM_SH:      /* R_SH_NONE.  */
12496     case EM_SPARC32PLUS:
12497     case EM_SPARC:   /* R_SPARC_NONE.  */
12498     case EM_SPARCV9:
12499     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12500     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12501     case EM_TI_C6000:/* R_C6000_NONE.  */
12502     case EM_X86_64:  /* R_X86_64_NONE.  */
12503     case EM_XC16X:
12504     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12505       return reloc_type == 0;
12506
12507     case EM_AARCH64:
12508       return reloc_type == 0 || reloc_type == 256;
12509     case EM_AVR_OLD:
12510     case EM_AVR:
12511       return (reloc_type == 0 /* R_AVR_NONE.  */
12512               || reloc_type == 30 /* R_AVR_DIFF8.  */
12513               || reloc_type == 31 /* R_AVR_DIFF16.  */
12514               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12515     case EM_METAG:
12516       return reloc_type == 3; /* R_METAG_NONE.  */
12517     case EM_NDS32:
12518       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12519               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12520               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12521               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12522               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12523     case EM_TI_PRU:
12524       return (reloc_type == 0       /* R_PRU_NONE.  */
12525               || reloc_type == 65   /* R_PRU_DIFF8.  */
12526               || reloc_type == 66   /* R_PRU_DIFF16.  */
12527               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12528     case EM_XTENSA_OLD:
12529     case EM_XTENSA:
12530       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12531               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12532               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12533               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12534     }
12535   return FALSE;
12536 }
12537
12538 /* Returns TRUE if there is a relocation against
12539    section NAME at OFFSET bytes.  */
12540
12541 bfd_boolean
12542 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12543 {
12544   Elf_Internal_Rela * relocs;
12545   Elf_Internal_Rela * rp;
12546
12547   if (dsec == NULL || dsec->reloc_info == NULL)
12548     return FALSE;
12549
12550   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12551
12552   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12553     if (rp->r_offset == offset)
12554       return TRUE;
12555
12556    return FALSE;
12557 }
12558
12559 /* Apply relocations to a section.
12560    Returns TRUE upon success, FALSE otherwise.
12561    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12562    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12563    will be set to the number of relocs loaded.
12564
12565    Note: So far support has been added only for those relocations
12566    which can be found in debug sections. FIXME: Add support for
12567    more relocations ?  */
12568
12569 static bfd_boolean
12570 apply_relocations (void *                     file,
12571                    const Elf_Internal_Shdr *  section,
12572                    unsigned char *            start,
12573                    bfd_size_type              size,
12574                    void **                    relocs_return,
12575                    unsigned long *            num_relocs_return)
12576 {
12577   Elf_Internal_Shdr * relsec;
12578   unsigned char * end = start + size;
12579   bfd_boolean res = TRUE;
12580
12581   if (relocs_return != NULL)
12582     {
12583       * (Elf_Internal_Rela **) relocs_return = NULL;
12584       * num_relocs_return = 0;
12585     }
12586
12587   if (elf_header.e_type != ET_REL)
12588     /* No relocs to apply.  */
12589     return TRUE;
12590
12591   /* Find the reloc section associated with the section.  */
12592   for (relsec = section_headers;
12593        relsec < section_headers + elf_header.e_shnum;
12594        ++relsec)
12595     {
12596       bfd_boolean is_rela;
12597       unsigned long num_relocs;
12598       Elf_Internal_Rela * relocs;
12599       Elf_Internal_Rela * rp;
12600       Elf_Internal_Shdr * symsec;
12601       Elf_Internal_Sym * symtab;
12602       unsigned long num_syms;
12603       Elf_Internal_Sym * sym;
12604
12605       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12606           || relsec->sh_info >= elf_header.e_shnum
12607           || section_headers + relsec->sh_info != section
12608           || relsec->sh_size == 0
12609           || relsec->sh_link >= elf_header.e_shnum)
12610         continue;
12611
12612       is_rela = relsec->sh_type == SHT_RELA;
12613
12614       if (is_rela)
12615         {
12616           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12617                                   relsec->sh_size, & relocs, & num_relocs))
12618             return FALSE;
12619         }
12620       else
12621         {
12622           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12623                                  relsec->sh_size, & relocs, & num_relocs))
12624             return FALSE;
12625         }
12626
12627       /* SH uses RELA but uses in place value instead of the addend field.  */
12628       if (elf_header.e_machine == EM_SH)
12629         is_rela = FALSE;
12630
12631       symsec = section_headers + relsec->sh_link;
12632       if (symsec->sh_type != SHT_SYMTAB
12633           && symsec->sh_type != SHT_DYNSYM)
12634         return FALSE;
12635       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12636
12637       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12638         {
12639           bfd_vma         addend;
12640           unsigned int    reloc_type;
12641           unsigned int    reloc_size;
12642           unsigned char * rloc;
12643           unsigned long   sym_index;
12644
12645           reloc_type = get_reloc_type (rp->r_info);
12646
12647           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12648             continue;
12649           else if (is_none_reloc (reloc_type))
12650             continue;
12651           else if (is_32bit_abs_reloc (reloc_type)
12652                    || is_32bit_pcrel_reloc (reloc_type))
12653             reloc_size = 4;
12654           else if (is_64bit_abs_reloc (reloc_type)
12655                    || is_64bit_pcrel_reloc (reloc_type))
12656             reloc_size = 8;
12657           else if (is_24bit_abs_reloc (reloc_type))
12658             reloc_size = 3;
12659           else if (is_16bit_abs_reloc (reloc_type))
12660             reloc_size = 2;
12661           else
12662             {
12663               static unsigned int prev_reloc = 0;
12664               if (reloc_type != prev_reloc)
12665                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12666                       reloc_type, printable_section_name (section));
12667               prev_reloc = reloc_type;
12668               res = FALSE;
12669               continue;
12670             }
12671
12672           rloc = start + rp->r_offset;
12673           if ((rloc + reloc_size) > end || (rloc < start))
12674             {
12675               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12676                     (unsigned long) rp->r_offset,
12677                     printable_section_name (section));
12678               res = FALSE;
12679               continue;
12680             }
12681
12682           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12683           if (sym_index >= num_syms)
12684             {
12685               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12686                     sym_index, printable_section_name (section));
12687               res = FALSE;
12688               continue;
12689             }
12690           sym = symtab + sym_index;
12691
12692           /* If the reloc has a symbol associated with it,
12693              make sure that it is of an appropriate type.
12694
12695              Relocations against symbols without type can happen.
12696              Gcc -feliminate-dwarf2-dups may generate symbols
12697              without type for debug info.
12698
12699              Icc generates relocations against function symbols
12700              instead of local labels.
12701
12702              Relocations against object symbols can happen, eg when
12703              referencing a global array.  For an example of this see
12704              the _clz.o binary in libgcc.a.  */
12705           if (sym != symtab
12706               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12707               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12708             {
12709               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12710                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12711                     (long int)(rp - relocs),
12712                     printable_section_name (relsec));
12713               res = FALSE;
12714               continue;
12715             }
12716
12717           addend = 0;
12718           if (is_rela)
12719             addend += rp->r_addend;
12720           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12721              partial_inplace.  */
12722           if (!is_rela
12723               || (elf_header.e_machine == EM_XTENSA
12724                   && reloc_type == 1)
12725               || ((elf_header.e_machine == EM_PJ
12726                    || elf_header.e_machine == EM_PJ_OLD)
12727                   && reloc_type == 1)
12728               || ((elf_header.e_machine == EM_D30V
12729                    || elf_header.e_machine == EM_CYGNUS_D30V)
12730                   && reloc_type == 12))
12731             addend += byte_get (rloc, reloc_size);
12732
12733           if (is_32bit_pcrel_reloc (reloc_type)
12734               || is_64bit_pcrel_reloc (reloc_type))
12735             {
12736               /* On HPPA, all pc-relative relocations are biased by 8.  */
12737               if (elf_header.e_machine == EM_PARISC)
12738                 addend -= 8;
12739               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12740                         reloc_size);
12741             }
12742           else
12743             byte_put (rloc, addend + sym->st_value, reloc_size);
12744         }
12745
12746       free (symtab);
12747       /* Let the target specific reloc processing code know that
12748          we have finished with these relocs.  */
12749       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12750
12751       if (relocs_return)
12752         {
12753           * (Elf_Internal_Rela **) relocs_return = relocs;
12754           * num_relocs_return = num_relocs;
12755         }
12756       else
12757         free (relocs);
12758
12759       break;
12760     }
12761
12762   return res;
12763 }
12764
12765 #ifdef SUPPORT_DISASSEMBLY
12766 static bfd_boolean
12767 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12768 {
12769   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12770
12771   /* FIXME: XXX -- to be done --- XXX */
12772
12773   return TRUE;
12774 }
12775 #endif
12776
12777 /* Reads in the contents of SECTION from FILE, returning a pointer
12778    to a malloc'ed buffer or NULL if something went wrong.  */
12779
12780 static char *
12781 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12782 {
12783   bfd_size_type num_bytes;
12784
12785   num_bytes = section->sh_size;
12786
12787   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12788     {
12789       printf (_("Section '%s' has no data to dump.\n"),
12790               printable_section_name (section));
12791       return NULL;
12792     }
12793
12794   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12795                              _("section contents"));
12796 }
12797
12798 /* Uncompresses a section that was compressed using zlib, in place.  */
12799
12800 static bfd_boolean
12801 uncompress_section_contents (unsigned char **buffer,
12802                              dwarf_size_type uncompressed_size,
12803                              dwarf_size_type *size)
12804 {
12805   dwarf_size_type compressed_size = *size;
12806   unsigned char * compressed_buffer = *buffer;
12807   unsigned char * uncompressed_buffer;
12808   z_stream strm;
12809   int rc;
12810
12811   /* It is possible the section consists of several compressed
12812      buffers concatenated together, so we uncompress in a loop.  */
12813   /* PR 18313: The state field in the z_stream structure is supposed
12814      to be invisible to the user (ie us), but some compilers will
12815      still complain about it being used without initialisation.  So
12816      we first zero the entire z_stream structure and then set the fields
12817      that we need.  */
12818   memset (& strm, 0, sizeof strm);
12819   strm.avail_in = compressed_size;
12820   strm.next_in = (Bytef *) compressed_buffer;
12821   strm.avail_out = uncompressed_size;
12822   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12823
12824   rc = inflateInit (& strm);
12825   while (strm.avail_in > 0)
12826     {
12827       if (rc != Z_OK)
12828         goto fail;
12829       strm.next_out = ((Bytef *) uncompressed_buffer
12830                        + (uncompressed_size - strm.avail_out));
12831       rc = inflate (&strm, Z_FINISH);
12832       if (rc != Z_STREAM_END)
12833         goto fail;
12834       rc = inflateReset (& strm);
12835     }
12836   rc = inflateEnd (& strm);
12837   if (rc != Z_OK
12838       || strm.avail_out != 0)
12839     goto fail;
12840
12841   *buffer = uncompressed_buffer;
12842   *size = uncompressed_size;
12843   return TRUE;
12844
12845  fail:
12846   free (uncompressed_buffer);
12847   /* Indicate decompression failure.  */
12848   *buffer = NULL;
12849   return FALSE;
12850 }
12851
12852 static bfd_boolean
12853 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12854 {
12855   Elf_Internal_Shdr *  relsec;
12856   bfd_size_type        num_bytes;
12857   unsigned char *      data;
12858   unsigned char *      end;
12859   unsigned char *      real_start;
12860   unsigned char *      start;
12861   bfd_boolean          some_strings_shown;
12862
12863   real_start = start = (unsigned char *) get_section_contents (section, file);
12864   if (start == NULL)
12865     /* PR 21820: Do not fail if the section was empty.  */
12866     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12867
12868   num_bytes = section->sh_size;
12869
12870   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12871
12872   if (decompress_dumps)
12873     {
12874       dwarf_size_type new_size = num_bytes;
12875       dwarf_size_type uncompressed_size = 0;
12876
12877       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12878         {
12879           Elf_Internal_Chdr chdr;
12880           unsigned int compression_header_size
12881             = get_compression_header (& chdr, (unsigned char *) start,
12882                                       num_bytes);
12883
12884           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12885             {
12886               warn (_("section '%s' has unsupported compress type: %d\n"),
12887                     printable_section_name (section), chdr.ch_type);
12888               return FALSE;
12889             }
12890           else if (chdr.ch_addralign != section->sh_addralign)
12891             {
12892               warn (_("compressed section '%s' is corrupted\n"),
12893                     printable_section_name (section));
12894               return FALSE;
12895             }
12896           uncompressed_size = chdr.ch_size;
12897           start += compression_header_size;
12898           new_size -= compression_header_size;
12899         }
12900       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12901         {
12902           /* Read the zlib header.  In this case, it should be "ZLIB"
12903              followed by the uncompressed section size, 8 bytes in
12904              big-endian order.  */
12905           uncompressed_size = start[4]; uncompressed_size <<= 8;
12906           uncompressed_size += start[5]; uncompressed_size <<= 8;
12907           uncompressed_size += start[6]; uncompressed_size <<= 8;
12908           uncompressed_size += start[7]; uncompressed_size <<= 8;
12909           uncompressed_size += start[8]; uncompressed_size <<= 8;
12910           uncompressed_size += start[9]; uncompressed_size <<= 8;
12911           uncompressed_size += start[10]; uncompressed_size <<= 8;
12912           uncompressed_size += start[11];
12913           start += 12;
12914           new_size -= 12;
12915         }
12916
12917       if (uncompressed_size)
12918         {
12919           if (uncompress_section_contents (& start,
12920                                            uncompressed_size, & new_size))
12921             num_bytes = new_size;
12922           else
12923             {
12924               error (_("Unable to decompress section %s\n"),
12925                      printable_section_name (section));
12926               return FALSE;
12927             }
12928         }
12929       else
12930         start = real_start;
12931     }
12932
12933   /* If the section being dumped has relocations against it the user might
12934      be expecting these relocations to have been applied.  Check for this
12935      case and issue a warning message in order to avoid confusion.
12936      FIXME: Maybe we ought to have an option that dumps a section with
12937      relocs applied ?  */
12938   for (relsec = section_headers;
12939        relsec < section_headers + elf_header.e_shnum;
12940        ++relsec)
12941     {
12942       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12943           || relsec->sh_info >= elf_header.e_shnum
12944           || section_headers + relsec->sh_info != section
12945           || relsec->sh_size == 0
12946           || relsec->sh_link >= elf_header.e_shnum)
12947         continue;
12948
12949       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12950       break;
12951     }
12952
12953   data = start;
12954   end  = start + num_bytes;
12955   some_strings_shown = FALSE;
12956
12957   while (data < end)
12958     {
12959       while (!ISPRINT (* data))
12960         if (++ data >= end)
12961           break;
12962
12963       if (data < end)
12964         {
12965           size_t maxlen = end - data;
12966
12967 #ifndef __MSVCRT__
12968           /* PR 11128: Use two separate invocations in order to work
12969              around bugs in the Solaris 8 implementation of printf.  */
12970           printf ("  [%6tx]  ", data - start);
12971 #else
12972           printf ("  [%6Ix]  ", (size_t) (data - start));
12973 #endif
12974           if (maxlen > 0)
12975             {
12976               print_symbol ((int) maxlen, (const char *) data);
12977               putchar ('\n');
12978               data += strnlen ((const char *) data, maxlen);
12979             }
12980           else
12981             {
12982               printf (_("<corrupt>\n"));
12983               data = end;
12984             }
12985           some_strings_shown = TRUE;
12986         }
12987     }
12988
12989   if (! some_strings_shown)
12990     printf (_("  No strings found in this section."));
12991
12992   free (real_start);
12993
12994   putchar ('\n');
12995   return TRUE;
12996 }
12997
12998 static bfd_boolean
12999 dump_section_as_bytes (Elf_Internal_Shdr * section,
13000                        FILE * file,
13001                        bfd_boolean relocate)
13002 {
13003   Elf_Internal_Shdr * relsec;
13004   bfd_size_type       bytes;
13005   bfd_size_type       section_size;
13006   bfd_vma             addr;
13007   unsigned char *     data;
13008   unsigned char *     real_start;
13009   unsigned char *     start;
13010
13011   real_start = start = (unsigned char *) get_section_contents (section, file);
13012   if (start == NULL)
13013     /* PR 21820: Do not fail if the section was empty.  */
13014     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13015
13016   section_size = section->sh_size;
13017
13018   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
13019
13020   if (decompress_dumps)
13021     {
13022       dwarf_size_type new_size = section_size;
13023       dwarf_size_type uncompressed_size = 0;
13024
13025       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13026         {
13027           Elf_Internal_Chdr chdr;
13028           unsigned int compression_header_size
13029             = get_compression_header (& chdr, start, section_size);
13030
13031           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13032             {
13033               warn (_("section '%s' has unsupported compress type: %d\n"),
13034                     printable_section_name (section), chdr.ch_type);
13035               return FALSE;
13036             }
13037           else if (chdr.ch_addralign != section->sh_addralign)
13038             {
13039               warn (_("compressed section '%s' is corrupted\n"),
13040                     printable_section_name (section));
13041               return FALSE;
13042             }
13043           uncompressed_size = chdr.ch_size;
13044           start += compression_header_size;
13045           new_size -= compression_header_size;
13046         }
13047       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13048         {
13049           /* Read the zlib header.  In this case, it should be "ZLIB"
13050              followed by the uncompressed section size, 8 bytes in
13051              big-endian order.  */
13052           uncompressed_size = start[4]; uncompressed_size <<= 8;
13053           uncompressed_size += start[5]; uncompressed_size <<= 8;
13054           uncompressed_size += start[6]; uncompressed_size <<= 8;
13055           uncompressed_size += start[7]; uncompressed_size <<= 8;
13056           uncompressed_size += start[8]; uncompressed_size <<= 8;
13057           uncompressed_size += start[9]; uncompressed_size <<= 8;
13058           uncompressed_size += start[10]; uncompressed_size <<= 8;
13059           uncompressed_size += start[11];
13060           start += 12;
13061           new_size -= 12;
13062         }
13063
13064       if (uncompressed_size)
13065         {
13066           if (uncompress_section_contents (& start, uncompressed_size,
13067                                            & new_size))
13068             {
13069               section_size = new_size;
13070             }
13071           else
13072             {
13073               error (_("Unable to decompress section %s\n"),
13074                      printable_section_name (section));
13075               /* FIXME: Print the section anyway ?  */
13076               return FALSE;
13077             }
13078         }
13079       else
13080         start = real_start;
13081     }
13082
13083   if (relocate)
13084     {
13085       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13086         return FALSE;
13087     }
13088   else
13089     {
13090       /* If the section being dumped has relocations against it the user might
13091          be expecting these relocations to have been applied.  Check for this
13092          case and issue a warning message in order to avoid confusion.
13093          FIXME: Maybe we ought to have an option that dumps a section with
13094          relocs applied ?  */
13095       for (relsec = section_headers;
13096            relsec < section_headers + elf_header.e_shnum;
13097            ++relsec)
13098         {
13099           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13100               || relsec->sh_info >= elf_header.e_shnum
13101               || section_headers + relsec->sh_info != section
13102               || relsec->sh_size == 0
13103               || relsec->sh_link >= elf_header.e_shnum)
13104             continue;
13105
13106           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13107           break;
13108         }
13109     }
13110
13111   addr = section->sh_addr;
13112   bytes = section_size;
13113   data = start;
13114
13115   while (bytes)
13116     {
13117       int j;
13118       int k;
13119       int lbytes;
13120
13121       lbytes = (bytes > 16 ? 16 : bytes);
13122
13123       printf ("  0x%8.8lx ", (unsigned long) addr);
13124
13125       for (j = 0; j < 16; j++)
13126         {
13127           if (j < lbytes)
13128             printf ("%2.2x", data[j]);
13129           else
13130             printf ("  ");
13131
13132           if ((j & 3) == 3)
13133             printf (" ");
13134         }
13135
13136       for (j = 0; j < lbytes; j++)
13137         {
13138           k = data[j];
13139           if (k >= ' ' && k < 0x7f)
13140             printf ("%c", k);
13141           else
13142             printf (".");
13143         }
13144
13145       putchar ('\n');
13146
13147       data  += lbytes;
13148       addr  += lbytes;
13149       bytes -= lbytes;
13150     }
13151
13152   free (real_start);
13153
13154   putchar ('\n');
13155   return TRUE;
13156 }
13157
13158 static bfd_boolean
13159 load_specific_debug_section (enum dwarf_section_display_enum debug,
13160                              const Elf_Internal_Shdr * sec, void * file)
13161 {
13162   struct dwarf_section * section = &debug_displays [debug].section;
13163   char buf [64];
13164
13165   /* If it is already loaded, do nothing.  */
13166   if (section->start != NULL)
13167     return TRUE;
13168
13169   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13170   section->address = sec->sh_addr;
13171   section->user_data = NULL;
13172   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13173                                                sec->sh_offset, 1,
13174                                                sec->sh_size, buf);
13175   if (section->start == NULL)
13176     section->size = 0;
13177   else
13178     {
13179       unsigned char *start = section->start;
13180       dwarf_size_type size = sec->sh_size;
13181       dwarf_size_type uncompressed_size = 0;
13182
13183       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13184         {
13185           Elf_Internal_Chdr chdr;
13186           unsigned int compression_header_size;
13187
13188           if (size < (is_32bit_elf
13189                       ? sizeof (Elf32_External_Chdr)
13190                       : sizeof (Elf64_External_Chdr)))
13191             {
13192               warn (_("compressed section %s is too small to contain a compression header"),
13193                     section->name);
13194               return FALSE;
13195             }
13196
13197           compression_header_size = get_compression_header (&chdr, start, size);
13198
13199           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13200             {
13201               warn (_("section '%s' has unsupported compress type: %d\n"),
13202                     section->name, chdr.ch_type);
13203               return FALSE;
13204             }
13205           else if (chdr.ch_addralign != sec->sh_addralign)
13206             {
13207               warn (_("compressed section '%s' is corrupted\n"),
13208                     section->name);
13209               return FALSE;
13210             }
13211           uncompressed_size = chdr.ch_size;
13212           start += compression_header_size;
13213           size -= compression_header_size;
13214         }
13215       else if (size > 12 && streq ((char *) start, "ZLIB"))
13216         {
13217           /* Read the zlib header.  In this case, it should be "ZLIB"
13218              followed by the uncompressed section size, 8 bytes in
13219              big-endian order.  */
13220           uncompressed_size = start[4]; uncompressed_size <<= 8;
13221           uncompressed_size += start[5]; uncompressed_size <<= 8;
13222           uncompressed_size += start[6]; uncompressed_size <<= 8;
13223           uncompressed_size += start[7]; uncompressed_size <<= 8;
13224           uncompressed_size += start[8]; uncompressed_size <<= 8;
13225           uncompressed_size += start[9]; uncompressed_size <<= 8;
13226           uncompressed_size += start[10]; uncompressed_size <<= 8;
13227           uncompressed_size += start[11];
13228           start += 12;
13229           size -= 12;
13230         }
13231
13232       if (uncompressed_size)
13233         {
13234           if (uncompress_section_contents (&start, uncompressed_size,
13235                                            &size))
13236             {
13237               /* Free the compressed buffer, update the section buffer
13238                  and the section size if uncompress is successful.  */
13239               free (section->start);
13240               section->start = start;
13241             }
13242           else
13243             {
13244               error (_("Unable to decompress section %s\n"),
13245                      printable_section_name (sec));
13246               return FALSE;
13247             }
13248         }
13249
13250       section->size = size;
13251     }
13252
13253   if (section->start == NULL)
13254     return FALSE;
13255
13256   if (debug_displays [debug].relocate)
13257     {
13258       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13259                                & section->reloc_info, & section->num_relocs))
13260         return FALSE;
13261     }
13262   else
13263     {
13264       section->reloc_info = NULL;
13265       section->num_relocs = 0;
13266     }
13267
13268   return TRUE;
13269 }
13270
13271 /* If this is not NULL, load_debug_section will only look for sections
13272    within the list of sections given here.  */
13273 static unsigned int * section_subset = NULL;
13274
13275 bfd_boolean
13276 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13277 {
13278   struct dwarf_section * section = &debug_displays [debug].section;
13279   Elf_Internal_Shdr * sec;
13280
13281   /* Locate the debug section.  */
13282   sec = find_section_in_set (section->uncompressed_name, section_subset);
13283   if (sec != NULL)
13284     section->name = section->uncompressed_name;
13285   else
13286     {
13287       sec = find_section_in_set (section->compressed_name, section_subset);
13288       if (sec != NULL)
13289         section->name = section->compressed_name;
13290     }
13291   if (sec == NULL)
13292     return FALSE;
13293
13294   /* If we're loading from a subset of sections, and we've loaded
13295      a section matching this name before, it's likely that it's a
13296      different one.  */
13297   if (section_subset != NULL)
13298     free_debug_section (debug);
13299
13300   return load_specific_debug_section (debug, sec, (FILE *) file);
13301 }
13302
13303 void
13304 free_debug_section (enum dwarf_section_display_enum debug)
13305 {
13306   struct dwarf_section * section = &debug_displays [debug].section;
13307
13308   if (section->start == NULL)
13309     return;
13310
13311   free ((char *) section->start);
13312   section->start = NULL;
13313   section->address = 0;
13314   section->size = 0;
13315 }
13316
13317 static bfd_boolean
13318 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13319 {
13320   char * name = SECTION_NAME (section);
13321   const char * print_name = printable_section_name (section);
13322   bfd_size_type length;
13323   bfd_boolean result = TRUE;
13324   int i;
13325
13326   length = section->sh_size;
13327   if (length == 0)
13328     {
13329       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13330       return TRUE;
13331     }
13332   if (section->sh_type == SHT_NOBITS)
13333     {
13334       /* There is no point in dumping the contents of a debugging section
13335          which has the NOBITS type - the bits in the file will be random.
13336          This can happen when a file containing a .eh_frame section is
13337          stripped with the --only-keep-debug command line option.  */
13338       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13339               print_name);
13340       return FALSE;
13341     }
13342
13343   if (const_strneq (name, ".gnu.linkonce.wi."))
13344     name = ".debug_info";
13345
13346   /* See if we know how to display the contents of this section.  */
13347   for (i = 0; i < max; i++)
13348     if (streq (debug_displays[i].section.uncompressed_name, name)
13349         || (i == line && const_strneq (name, ".debug_line."))
13350         || streq (debug_displays[i].section.compressed_name, name))
13351       {
13352         struct dwarf_section * sec = &debug_displays [i].section;
13353         int secondary = (section != find_section (name));
13354
13355         if (secondary)
13356           free_debug_section ((enum dwarf_section_display_enum) i);
13357
13358         if (i == line && const_strneq (name, ".debug_line."))
13359           sec->name = name;
13360         else if (streq (sec->uncompressed_name, name))
13361           sec->name = sec->uncompressed_name;
13362         else
13363           sec->name = sec->compressed_name;
13364         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13365                                          section, file))
13366           {
13367             /* If this debug section is part of a CU/TU set in a .dwp file,
13368                restrict load_debug_section to the sections in that set.  */
13369             section_subset = find_cu_tu_set (file, shndx);
13370
13371             result &= debug_displays[i].display (sec, file);
13372
13373             section_subset = NULL;
13374
13375             if (secondary || (i != info && i != abbrev))
13376               free_debug_section ((enum dwarf_section_display_enum) i);
13377           }
13378
13379         break;
13380       }
13381
13382   if (i == max)
13383     {
13384       printf (_("Unrecognized debug section: %s\n"), print_name);
13385       result = FALSE;
13386     }
13387
13388   return result;
13389 }
13390
13391 /* Set DUMP_SECTS for all sections where dumps were requested
13392    based on section name.  */
13393
13394 static void
13395 initialise_dumps_byname (void)
13396 {
13397   struct dump_list_entry * cur;
13398
13399   for (cur = dump_sects_byname; cur; cur = cur->next)
13400     {
13401       unsigned int i;
13402       bfd_boolean any = FALSE;
13403
13404       for (i = 0; i < elf_header.e_shnum; i++)
13405         if (streq (SECTION_NAME (section_headers + i), cur->name))
13406           {
13407             request_dump_bynumber (i, cur->type);
13408             any = TRUE;
13409           }
13410
13411       if (!any)
13412         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13413               cur->name);
13414     }
13415 }
13416
13417 static bfd_boolean
13418 process_section_contents (FILE * file)
13419 {
13420   Elf_Internal_Shdr * section;
13421   unsigned int i;
13422   bfd_boolean res = TRUE;
13423
13424   if (! do_dump)
13425     return TRUE;
13426
13427   initialise_dumps_byname ();
13428
13429   for (i = 0, section = section_headers;
13430        i < elf_header.e_shnum && i < num_dump_sects;
13431        i++, section++)
13432     {
13433 #ifdef SUPPORT_DISASSEMBLY
13434       if (dump_sects[i] & DISASS_DUMP)
13435         disassemble_section (section, file);
13436 #endif
13437       if (dump_sects[i] & HEX_DUMP)
13438         {
13439           if (! dump_section_as_bytes (section, file, FALSE))
13440             res = FALSE;
13441         }
13442
13443       if (dump_sects[i] & RELOC_DUMP)
13444         {
13445           if (! dump_section_as_bytes (section, file, TRUE))
13446             res = FALSE;
13447         }
13448
13449       if (dump_sects[i] & STRING_DUMP)
13450         {
13451           if (! dump_section_as_strings (section, file))
13452             res = FALSE;
13453         }
13454
13455       if (dump_sects[i] & DEBUG_DUMP)
13456         {
13457           if (! display_debug_section (i, section, file))
13458             res = FALSE;
13459         }
13460     }
13461
13462   /* Check to see if the user requested a
13463      dump of a section that does not exist.  */
13464   while (i < num_dump_sects)
13465     {
13466       if (dump_sects[i])
13467         {
13468           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13469           res = FALSE;
13470         }
13471       i++;
13472     }
13473
13474   return res;
13475 }
13476
13477 static void
13478 process_mips_fpe_exception (int mask)
13479 {
13480   if (mask)
13481     {
13482       bfd_boolean first = TRUE;
13483
13484       if (mask & OEX_FPU_INEX)
13485         fputs ("INEX", stdout), first = FALSE;
13486       if (mask & OEX_FPU_UFLO)
13487         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13488       if (mask & OEX_FPU_OFLO)
13489         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13490       if (mask & OEX_FPU_DIV0)
13491         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13492       if (mask & OEX_FPU_INVAL)
13493         printf ("%sINVAL", first ? "" : "|");
13494     }
13495   else
13496     fputs ("0", stdout);
13497 }
13498
13499 /* Display's the value of TAG at location P.  If TAG is
13500    greater than 0 it is assumed to be an unknown tag, and
13501    a message is printed to this effect.  Otherwise it is
13502    assumed that a message has already been printed.
13503
13504    If the bottom bit of TAG is set it assumed to have a
13505    string value, otherwise it is assumed to have an integer
13506    value.
13507
13508    Returns an updated P pointing to the first unread byte
13509    beyond the end of TAG's value.
13510
13511    Reads at or beyond END will not be made.  */
13512
13513 static unsigned char *
13514 display_tag_value (signed int tag,
13515                    unsigned char * p,
13516                    const unsigned char * const end)
13517 {
13518   unsigned long val;
13519
13520   if (tag > 0)
13521     printf ("  Tag_unknown_%d: ", tag);
13522
13523   if (p >= end)
13524     {
13525       warn (_("<corrupt tag>\n"));
13526     }
13527   else if (tag & 1)
13528     {
13529       /* PR 17531 file: 027-19978-0.004.  */
13530       size_t maxlen = (end - p) - 1;
13531
13532       putchar ('"');
13533       if (maxlen > 0)
13534         {
13535           print_symbol ((int) maxlen, (const char *) p);
13536           p += strnlen ((char *) p, maxlen) + 1;
13537         }
13538       else
13539         {
13540           printf (_("<corrupt string tag>"));
13541           p = (unsigned char *) end;
13542         }
13543       printf ("\"\n");
13544     }
13545   else
13546     {
13547       unsigned int len;
13548
13549       val = read_uleb128 (p, &len, end);
13550       p += len;
13551       printf ("%ld (0x%lx)\n", val, val);
13552     }
13553
13554   assert (p <= end);
13555   return p;
13556 }
13557
13558 /* ARC ABI attributes section.  */
13559
13560 static unsigned char *
13561 display_arc_attribute (unsigned char * p,
13562                        const unsigned char * const end)
13563 {
13564   unsigned int tag;
13565   unsigned int len;
13566   unsigned int val;
13567
13568   tag = read_uleb128 (p, &len, end);
13569   p += len;
13570
13571   switch (tag)
13572     {
13573     case Tag_ARC_PCS_config:
13574       val = read_uleb128 (p, &len, end);
13575       p += len;
13576       printf ("  Tag_ARC_PCS_config: ");
13577       switch (val)
13578         {
13579         case 0:
13580           printf (_("Absent/Non standard\n"));
13581           break;
13582         case 1:
13583           printf (_("Bare metal/mwdt\n"));
13584           break;
13585         case 2:
13586           printf (_("Bare metal/newlib\n"));
13587           break;
13588         case 3:
13589           printf (_("Linux/uclibc\n"));
13590           break;
13591         case 4:
13592           printf (_("Linux/glibc\n"));
13593           break;
13594         default:
13595           printf (_("Unknown\n"));
13596           break;
13597         }
13598       break;
13599
13600     case Tag_ARC_CPU_base:
13601       val = read_uleb128 (p, &len, end);
13602       p += len;
13603       printf ("  Tag_ARC_CPU_base: ");
13604       switch (val)
13605         {
13606         default:
13607         case TAG_CPU_NONE:
13608           printf (_("Absent\n"));
13609           break;
13610         case TAG_CPU_ARC6xx:
13611           printf ("ARC6xx\n");
13612           break;
13613         case TAG_CPU_ARC7xx:
13614           printf ("ARC7xx\n");
13615           break;
13616         case TAG_CPU_ARCEM:
13617           printf ("ARCEM\n");
13618           break;
13619         case TAG_CPU_ARCHS:
13620           printf ("ARCHS\n");
13621           break;
13622         }
13623       break;
13624
13625     case Tag_ARC_CPU_variation:
13626       val = read_uleb128 (p, &len, end);
13627       p += len;
13628       printf ("  Tag_ARC_CPU_variation: ");
13629       switch (val)
13630         {
13631         default:
13632           if (val > 0 && val < 16)
13633               printf ("Core%d\n", val);
13634           else
13635               printf ("Unknown\n");
13636           break;
13637
13638         case 0:
13639           printf (_("Absent\n"));
13640           break;
13641         }
13642       break;
13643
13644     case Tag_ARC_CPU_name:
13645       printf ("  Tag_ARC_CPU_name: ");
13646       p = display_tag_value (-1, p, end);
13647       break;
13648
13649     case Tag_ARC_ABI_rf16:
13650       val = read_uleb128 (p, &len, end);
13651       p += len;
13652       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13653       break;
13654
13655     case Tag_ARC_ABI_osver:
13656       val = read_uleb128 (p, &len, end);
13657       p += len;
13658       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13659       break;
13660
13661     case Tag_ARC_ABI_pic:
13662     case Tag_ARC_ABI_sda:
13663       val = read_uleb128 (p, &len, end);
13664       p += len;
13665       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13666               : "  Tag_ARC_ABI_pic: ");
13667       switch (val)
13668         {
13669         case 0:
13670           printf (_("Absent\n"));
13671           break;
13672         case 1:
13673           printf ("MWDT\n");
13674           break;
13675         case 2:
13676           printf ("GNU\n");
13677           break;
13678         default:
13679           printf (_("Unknown\n"));
13680           break;
13681         }
13682       break;
13683
13684     case Tag_ARC_ABI_tls:
13685       val = read_uleb128 (p, &len, end);
13686       p += len;
13687       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13688       break;
13689
13690     case Tag_ARC_ABI_enumsize:
13691       val = read_uleb128 (p, &len, end);
13692       p += len;
13693       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13694               _("smallest"));
13695       break;
13696
13697     case Tag_ARC_ABI_exceptions:
13698       val = read_uleb128 (p, &len, end);
13699       p += len;
13700       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13701               : _("default"));
13702       break;
13703
13704     case Tag_ARC_ABI_double_size:
13705       val = read_uleb128 (p, &len, end);
13706       p += len;
13707       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13708       break;
13709
13710     case Tag_ARC_ISA_config:
13711       printf ("  Tag_ARC_ISA_config: ");
13712       p = display_tag_value (-1, p, end);
13713       break;
13714
13715     case Tag_ARC_ISA_apex:
13716       printf ("  Tag_ARC_ISA_apex: ");
13717       p = display_tag_value (-1, p, end);
13718       break;
13719
13720     case Tag_ARC_ISA_mpy_option:
13721       val = read_uleb128 (p, &len, end);
13722       p += len;
13723       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13724       break;
13725
13726     default:
13727       return display_tag_value (tag & 1, p, end);
13728     }
13729
13730   return p;
13731 }
13732
13733 /* ARM EABI attributes section.  */
13734 typedef struct
13735 {
13736   unsigned int tag;
13737   const char * name;
13738   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13739   unsigned int type;
13740   const char ** table;
13741 } arm_attr_public_tag;
13742
13743 static const char * arm_attr_tag_CPU_arch[] =
13744   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13745    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13746    "v8-M.mainline"};
13747 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13748 static const char * arm_attr_tag_THUMB_ISA_use[] =
13749   {"No", "Thumb-1", "Thumb-2", "Yes"};
13750 static const char * arm_attr_tag_FP_arch[] =
13751   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13752    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13753 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13754 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13755   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13756    "NEON for ARMv8.1"};
13757 static const char * arm_attr_tag_PCS_config[] =
13758   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13759    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13760 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13761   {"V6", "SB", "TLS", "Unused"};
13762 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13763   {"Absolute", "PC-relative", "SB-relative", "None"};
13764 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13765   {"Absolute", "PC-relative", "None"};
13766 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13767   {"None", "direct", "GOT-indirect"};
13768 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13769   {"None", "??? 1", "2", "??? 3", "4"};
13770 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13771 static const char * arm_attr_tag_ABI_FP_denormal[] =
13772   {"Unused", "Needed", "Sign only"};
13773 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13774 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13775 static const char * arm_attr_tag_ABI_FP_number_model[] =
13776   {"Unused", "Finite", "RTABI", "IEEE 754"};
13777 static const char * arm_attr_tag_ABI_enum_size[] =
13778   {"Unused", "small", "int", "forced to int"};
13779 static const char * arm_attr_tag_ABI_HardFP_use[] =
13780   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13781 static const char * arm_attr_tag_ABI_VFP_args[] =
13782   {"AAPCS", "VFP registers", "custom", "compatible"};
13783 static const char * arm_attr_tag_ABI_WMMX_args[] =
13784   {"AAPCS", "WMMX registers", "custom"};
13785 static const char * arm_attr_tag_ABI_optimization_goals[] =
13786   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13787     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13788 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13789   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13790     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13791 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13792 static const char * arm_attr_tag_FP_HP_extension[] =
13793   {"Not Allowed", "Allowed"};
13794 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13795   {"None", "IEEE 754", "Alternative Format"};
13796 static const char * arm_attr_tag_DSP_extension[] =
13797   {"Follow architecture", "Allowed"};
13798 static const char * arm_attr_tag_MPextension_use[] =
13799   {"Not Allowed", "Allowed"};
13800 static const char * arm_attr_tag_DIV_use[] =
13801   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13802     "Allowed in v7-A with integer division extension"};
13803 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13804 static const char * arm_attr_tag_Virtualization_use[] =
13805   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13806     "TrustZone and Virtualization Extensions"};
13807 static const char * arm_attr_tag_MPextension_use_legacy[] =
13808   {"Not Allowed", "Allowed"};
13809
13810 #define LOOKUP(id, name) \
13811   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13812 static arm_attr_public_tag arm_attr_public_tags[] =
13813 {
13814   {4, "CPU_raw_name", 1, NULL},
13815   {5, "CPU_name", 1, NULL},
13816   LOOKUP(6, CPU_arch),
13817   {7, "CPU_arch_profile", 0, NULL},
13818   LOOKUP(8, ARM_ISA_use),
13819   LOOKUP(9, THUMB_ISA_use),
13820   LOOKUP(10, FP_arch),
13821   LOOKUP(11, WMMX_arch),
13822   LOOKUP(12, Advanced_SIMD_arch),
13823   LOOKUP(13, PCS_config),
13824   LOOKUP(14, ABI_PCS_R9_use),
13825   LOOKUP(15, ABI_PCS_RW_data),
13826   LOOKUP(16, ABI_PCS_RO_data),
13827   LOOKUP(17, ABI_PCS_GOT_use),
13828   LOOKUP(18, ABI_PCS_wchar_t),
13829   LOOKUP(19, ABI_FP_rounding),
13830   LOOKUP(20, ABI_FP_denormal),
13831   LOOKUP(21, ABI_FP_exceptions),
13832   LOOKUP(22, ABI_FP_user_exceptions),
13833   LOOKUP(23, ABI_FP_number_model),
13834   {24, "ABI_align_needed", 0, NULL},
13835   {25, "ABI_align_preserved", 0, NULL},
13836   LOOKUP(26, ABI_enum_size),
13837   LOOKUP(27, ABI_HardFP_use),
13838   LOOKUP(28, ABI_VFP_args),
13839   LOOKUP(29, ABI_WMMX_args),
13840   LOOKUP(30, ABI_optimization_goals),
13841   LOOKUP(31, ABI_FP_optimization_goals),
13842   {32, "compatibility", 0, NULL},
13843   LOOKUP(34, CPU_unaligned_access),
13844   LOOKUP(36, FP_HP_extension),
13845   LOOKUP(38, ABI_FP_16bit_format),
13846   LOOKUP(42, MPextension_use),
13847   LOOKUP(44, DIV_use),
13848   LOOKUP(46, DSP_extension),
13849   {64, "nodefaults", 0, NULL},
13850   {65, "also_compatible_with", 0, NULL},
13851   LOOKUP(66, T2EE_use),
13852   {67, "conformance", 1, NULL},
13853   LOOKUP(68, Virtualization_use),
13854   LOOKUP(70, MPextension_use_legacy)
13855 };
13856 #undef LOOKUP
13857
13858 static unsigned char *
13859 display_arm_attribute (unsigned char * p,
13860                        const unsigned char * const end)
13861 {
13862   unsigned int tag;
13863   unsigned int len;
13864   unsigned int val;
13865   arm_attr_public_tag * attr;
13866   unsigned i;
13867   unsigned int type;
13868
13869   tag = read_uleb128 (p, &len, end);
13870   p += len;
13871   attr = NULL;
13872   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13873     {
13874       if (arm_attr_public_tags[i].tag == tag)
13875         {
13876           attr = &arm_attr_public_tags[i];
13877           break;
13878         }
13879     }
13880
13881   if (attr)
13882     {
13883       printf ("  Tag_%s: ", attr->name);
13884       switch (attr->type)
13885         {
13886         case 0:
13887           switch (tag)
13888             {
13889             case 7: /* Tag_CPU_arch_profile.  */
13890               val = read_uleb128 (p, &len, end);
13891               p += len;
13892               switch (val)
13893                 {
13894                 case 0: printf (_("None\n")); break;
13895                 case 'A': printf (_("Application\n")); break;
13896                 case 'R': printf (_("Realtime\n")); break;
13897                 case 'M': printf (_("Microcontroller\n")); break;
13898                 case 'S': printf (_("Application or Realtime\n")); break;
13899                 default: printf ("??? (%d)\n", val); break;
13900                 }
13901               break;
13902
13903             case 24: /* Tag_align_needed.  */
13904               val = read_uleb128 (p, &len, end);
13905               p += len;
13906               switch (val)
13907                 {
13908                 case 0: printf (_("None\n")); break;
13909                 case 1: printf (_("8-byte\n")); break;
13910                 case 2: printf (_("4-byte\n")); break;
13911                 case 3: printf ("??? 3\n"); break;
13912                 default:
13913                   if (val <= 12)
13914                     printf (_("8-byte and up to %d-byte extended\n"),
13915                             1 << val);
13916                   else
13917                     printf ("??? (%d)\n", val);
13918                   break;
13919                 }
13920               break;
13921
13922             case 25: /* Tag_align_preserved.  */
13923               val = read_uleb128 (p, &len, end);
13924               p += len;
13925               switch (val)
13926                 {
13927                 case 0: printf (_("None\n")); break;
13928                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13929                 case 2: printf (_("8-byte\n")); break;
13930                 case 3: printf ("??? 3\n"); break;
13931                 default:
13932                   if (val <= 12)
13933                     printf (_("8-byte and up to %d-byte extended\n"),
13934                             1 << val);
13935                   else
13936                     printf ("??? (%d)\n", val);
13937                   break;
13938                 }
13939               break;
13940
13941             case 32: /* Tag_compatibility.  */
13942               {
13943                 val = read_uleb128 (p, &len, end);
13944                 p += len;
13945                 printf (_("flag = %d, vendor = "), val);
13946                 if (p < end - 1)
13947                   {
13948                     size_t maxlen = (end - p) - 1;
13949
13950                     print_symbol ((int) maxlen, (const char *) p);
13951                     p += strnlen ((char *) p, maxlen) + 1;
13952                   }
13953                 else
13954                   {
13955                     printf (_("<corrupt>"));
13956                     p = (unsigned char *) end;
13957                   }
13958                 putchar ('\n');
13959               }
13960               break;
13961
13962             case 64: /* Tag_nodefaults.  */
13963               /* PR 17531: file: 001-505008-0.01.  */
13964               if (p < end)
13965                 p++;
13966               printf (_("True\n"));
13967               break;
13968
13969             case 65: /* Tag_also_compatible_with.  */
13970               val = read_uleb128 (p, &len, end);
13971               p += len;
13972               if (val == 6 /* Tag_CPU_arch.  */)
13973                 {
13974                   val = read_uleb128 (p, &len, end);
13975                   p += len;
13976                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13977                     printf ("??? (%d)\n", val);
13978                   else
13979                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13980                 }
13981               else
13982                 printf ("???\n");
13983               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
13984                 ;
13985               break;
13986
13987             default:
13988               printf (_("<unknown: %d>\n"), tag);
13989               break;
13990             }
13991           return p;
13992
13993         case 1:
13994           return display_tag_value (-1, p, end);
13995         case 2:
13996           return display_tag_value (0, p, end);
13997
13998         default:
13999           assert (attr->type & 0x80);
14000           val = read_uleb128 (p, &len, end);
14001           p += len;
14002           type = attr->type & 0x7f;
14003           if (val >= type)
14004             printf ("??? (%d)\n", val);
14005           else
14006             printf ("%s\n", attr->table[val]);
14007           return p;
14008         }
14009     }
14010
14011   return display_tag_value (tag, p, end);
14012 }
14013
14014 static unsigned char *
14015 display_gnu_attribute (unsigned char * p,
14016                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14017                        const unsigned char * const end)
14018 {
14019   int tag;
14020   unsigned int len;
14021   unsigned int val;
14022
14023   tag = read_uleb128 (p, &len, end);
14024   p += len;
14025
14026   /* Tag_compatibility is the only generic GNU attribute defined at
14027      present.  */
14028   if (tag == 32)
14029     {
14030       val = read_uleb128 (p, &len, end);
14031       p += len;
14032
14033       printf (_("flag = %d, vendor = "), val);
14034       if (p == end)
14035         {
14036           printf (_("<corrupt>\n"));
14037           warn (_("corrupt vendor attribute\n"));
14038         }
14039       else
14040         {
14041           if (p < end - 1)
14042             {
14043               size_t maxlen = (end - p) - 1;
14044
14045               print_symbol ((int) maxlen, (const char *) p);
14046               p += strnlen ((char *) p, maxlen) + 1;
14047             }
14048           else
14049             {
14050               printf (_("<corrupt>"));
14051               p = (unsigned char *) end;
14052             }
14053           putchar ('\n');
14054         }
14055       return p;
14056     }
14057
14058   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14059     return display_proc_gnu_attribute (p, tag, end);
14060
14061   return display_tag_value (tag, p, end);
14062 }
14063
14064 static unsigned char *
14065 display_power_gnu_attribute (unsigned char * p,
14066                              unsigned int tag,
14067                              const unsigned char * const end)
14068 {
14069   unsigned int len;
14070   unsigned int val;
14071
14072   if (tag == Tag_GNU_Power_ABI_FP)
14073     {
14074       val = read_uleb128 (p, &len, end);
14075       p += len;
14076       printf ("  Tag_GNU_Power_ABI_FP: ");
14077       if (len == 0)
14078         {
14079           printf (_("<corrupt>\n"));
14080           return p;
14081         }
14082
14083       if (val > 15)
14084         printf ("(%#x), ", val);
14085
14086       switch (val & 3)
14087         {
14088         case 0:
14089           printf (_("unspecified hard/soft float, "));
14090           break;
14091         case 1:
14092           printf (_("hard float, "));
14093           break;
14094         case 2:
14095           printf (_("soft float, "));
14096           break;
14097         case 3:
14098           printf (_("single-precision hard float, "));
14099           break;
14100         }
14101
14102       switch (val & 0xC)
14103         {
14104         case 0:
14105           printf (_("unspecified long double\n"));
14106           break;
14107         case 4:
14108           printf (_("128-bit IBM long double\n"));
14109           break;
14110         case 8:
14111           printf (_("64-bit long double\n"));
14112           break;
14113         case 12:
14114           printf (_("128-bit IEEE long double\n"));
14115           break;
14116         }
14117       return p;
14118     }
14119
14120   if (tag == Tag_GNU_Power_ABI_Vector)
14121     {
14122       val = read_uleb128 (p, &len, end);
14123       p += len;
14124       printf ("  Tag_GNU_Power_ABI_Vector: ");
14125       if (len == 0)
14126         {
14127           printf (_("<corrupt>\n"));
14128           return p;
14129         }
14130
14131       if (val > 3)
14132         printf ("(%#x), ", val);
14133
14134       switch (val & 3)
14135         {
14136         case 0:
14137           printf (_("unspecified\n"));
14138           break;
14139         case 1:
14140           printf (_("generic\n"));
14141           break;
14142         case 2:
14143           printf ("AltiVec\n");
14144           break;
14145         case 3:
14146           printf ("SPE\n");
14147           break;
14148         }
14149       return p;
14150     }
14151
14152   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14153     {
14154       val = read_uleb128 (p, &len, end);
14155       p += len;
14156       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14157       if (len == 0)
14158         {
14159           printf (_("<corrupt>\n"));
14160           return p;
14161         }
14162
14163       if (val > 2)
14164         printf ("(%#x), ", val);
14165
14166       switch (val & 3)
14167         {
14168         case 0:
14169           printf (_("unspecified\n"));
14170           break;
14171         case 1:
14172           printf ("r3/r4\n");
14173           break;
14174         case 2:
14175           printf (_("memory\n"));
14176           break;
14177         case 3:
14178           printf ("???\n");
14179           break;
14180         }
14181       return p;
14182     }
14183
14184   return display_tag_value (tag & 1, p, end);
14185 }
14186
14187 static unsigned char *
14188 display_s390_gnu_attribute (unsigned char * p,
14189                             unsigned int tag,
14190                             const unsigned char * const end)
14191 {
14192   unsigned int len;
14193   int val;
14194
14195   if (tag == Tag_GNU_S390_ABI_Vector)
14196     {
14197       val = read_uleb128 (p, &len, end);
14198       p += len;
14199       printf ("  Tag_GNU_S390_ABI_Vector: ");
14200
14201       switch (val)
14202         {
14203         case 0:
14204           printf (_("any\n"));
14205           break;
14206         case 1:
14207           printf (_("software\n"));
14208           break;
14209         case 2:
14210           printf (_("hardware\n"));
14211           break;
14212         default:
14213           printf ("??? (%d)\n", val);
14214           break;
14215         }
14216       return p;
14217    }
14218
14219   return display_tag_value (tag & 1, p, end);
14220 }
14221
14222 static void
14223 display_sparc_hwcaps (unsigned int mask)
14224 {
14225   if (mask)
14226     {
14227       bfd_boolean first = TRUE;
14228
14229       if (mask & ELF_SPARC_HWCAP_MUL32)
14230         fputs ("mul32", stdout), first = FALSE;
14231       if (mask & ELF_SPARC_HWCAP_DIV32)
14232         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14233       if (mask & ELF_SPARC_HWCAP_FSMULD)
14234         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14235       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14236         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14237       if (mask & ELF_SPARC_HWCAP_POPC)
14238         printf ("%spopc", first ? "" : "|"), first = FALSE;
14239       if (mask & ELF_SPARC_HWCAP_VIS)
14240         printf ("%svis", first ? "" : "|"), first = FALSE;
14241       if (mask & ELF_SPARC_HWCAP_VIS2)
14242         printf ("%svis2", first ? "" : "|"), first = FALSE;
14243       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14244         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14245       if (mask & ELF_SPARC_HWCAP_FMAF)
14246         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14247       if (mask & ELF_SPARC_HWCAP_VIS3)
14248         printf ("%svis3", first ? "" : "|"), first = FALSE;
14249       if (mask & ELF_SPARC_HWCAP_HPC)
14250         printf ("%shpc", first ? "" : "|"), first = FALSE;
14251       if (mask & ELF_SPARC_HWCAP_RANDOM)
14252         printf ("%srandom", first ? "" : "|"), first = FALSE;
14253       if (mask & ELF_SPARC_HWCAP_TRANS)
14254         printf ("%strans", first ? "" : "|"), first = FALSE;
14255       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14256         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14257       if (mask & ELF_SPARC_HWCAP_IMA)
14258         printf ("%sima", first ? "" : "|"), first = FALSE;
14259       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14260         printf ("%scspare", first ? "" : "|"), first = FALSE;
14261     }
14262   else
14263     fputc ('0', stdout);
14264   fputc ('\n', stdout);
14265 }
14266
14267 static void
14268 display_sparc_hwcaps2 (unsigned int mask)
14269 {
14270   if (mask)
14271     {
14272       bfd_boolean first = TRUE;
14273
14274       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14275         fputs ("fjathplus", stdout), first = FALSE;
14276       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14277         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14278       if (mask & ELF_SPARC_HWCAP2_ADP)
14279         printf ("%sadp", first ? "" : "|"), first = FALSE;
14280       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14281         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14282       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14283         printf ("%smwait", first ? "" : "|"), first = FALSE;
14284       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14285         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14286       if (mask & ELF_SPARC_HWCAP2_XMONT)
14287         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14288       if (mask & ELF_SPARC_HWCAP2_NSEC)
14289         printf ("%snsec", first ? "" : "|"), first = FALSE;
14290       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14291         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14292       if (mask & ELF_SPARC_HWCAP2_FJDES)
14293         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14294       if (mask & ELF_SPARC_HWCAP2_FJAES)
14295         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14296     }
14297   else
14298     fputc ('0', stdout);
14299   fputc ('\n', stdout);
14300 }
14301
14302 static unsigned char *
14303 display_sparc_gnu_attribute (unsigned char * p,
14304                              unsigned int tag,
14305                              const unsigned char * const end)
14306 {
14307   unsigned int len;
14308   int val;
14309
14310   if (tag == Tag_GNU_Sparc_HWCAPS)
14311     {
14312       val = read_uleb128 (p, &len, end);
14313       p += len;
14314       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14315       display_sparc_hwcaps (val);
14316       return p;
14317     }
14318   if (tag == Tag_GNU_Sparc_HWCAPS2)
14319     {
14320       val = read_uleb128 (p, &len, end);
14321       p += len;
14322       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14323       display_sparc_hwcaps2 (val);
14324       return p;
14325     }
14326
14327   return display_tag_value (tag, p, end);
14328 }
14329
14330 static void
14331 print_mips_fp_abi_value (unsigned int val)
14332 {
14333   switch (val)
14334     {
14335     case Val_GNU_MIPS_ABI_FP_ANY:
14336       printf (_("Hard or soft float\n"));
14337       break;
14338     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14339       printf (_("Hard float (double precision)\n"));
14340       break;
14341     case Val_GNU_MIPS_ABI_FP_SINGLE:
14342       printf (_("Hard float (single precision)\n"));
14343       break;
14344     case Val_GNU_MIPS_ABI_FP_SOFT:
14345       printf (_("Soft float\n"));
14346       break;
14347     case Val_GNU_MIPS_ABI_FP_OLD_64:
14348       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14349       break;
14350     case Val_GNU_MIPS_ABI_FP_XX:
14351       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14352       break;
14353     case Val_GNU_MIPS_ABI_FP_64:
14354       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14355       break;
14356     case Val_GNU_MIPS_ABI_FP_64A:
14357       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14358       break;
14359     case Val_GNU_MIPS_ABI_FP_NAN2008:
14360       printf (_("NaN 2008 compatibility\n"));
14361       break;
14362     default:
14363       printf ("??? (%d)\n", val);
14364       break;
14365     }
14366 }
14367
14368 static unsigned char *
14369 display_mips_gnu_attribute (unsigned char * p,
14370                             unsigned int tag,
14371                             const unsigned char * const end)
14372 {
14373   if (tag == Tag_GNU_MIPS_ABI_FP)
14374     {
14375       unsigned int len;
14376       unsigned int val;
14377
14378       val = read_uleb128 (p, &len, end);
14379       p += len;
14380       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14381
14382       print_mips_fp_abi_value (val);
14383
14384       return p;
14385    }
14386
14387   if (tag == Tag_GNU_MIPS_ABI_MSA)
14388     {
14389       unsigned int len;
14390       unsigned int val;
14391
14392       val = read_uleb128 (p, &len, end);
14393       p += len;
14394       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14395
14396       switch (val)
14397         {
14398         case Val_GNU_MIPS_ABI_MSA_ANY:
14399           printf (_("Any MSA or not\n"));
14400           break;
14401         case Val_GNU_MIPS_ABI_MSA_128:
14402           printf (_("128-bit MSA\n"));
14403           break;
14404         default:
14405           printf ("??? (%d)\n", val);
14406           break;
14407         }
14408       return p;
14409     }
14410
14411   return display_tag_value (tag & 1, p, end);
14412 }
14413
14414 static unsigned char *
14415 display_tic6x_attribute (unsigned char * p,
14416                          const unsigned char * const end)
14417 {
14418   unsigned int tag;
14419   unsigned int len;
14420   int val;
14421
14422   tag = read_uleb128 (p, &len, end);
14423   p += len;
14424
14425   switch (tag)
14426     {
14427     case Tag_ISA:
14428       val = read_uleb128 (p, &len, end);
14429       p += len;
14430       printf ("  Tag_ISA: ");
14431
14432       switch (val)
14433         {
14434         case C6XABI_Tag_ISA_none:
14435           printf (_("None\n"));
14436           break;
14437         case C6XABI_Tag_ISA_C62X:
14438           printf ("C62x\n");
14439           break;
14440         case C6XABI_Tag_ISA_C67X:
14441           printf ("C67x\n");
14442           break;
14443         case C6XABI_Tag_ISA_C67XP:
14444           printf ("C67x+\n");
14445           break;
14446         case C6XABI_Tag_ISA_C64X:
14447           printf ("C64x\n");
14448           break;
14449         case C6XABI_Tag_ISA_C64XP:
14450           printf ("C64x+\n");
14451           break;
14452         case C6XABI_Tag_ISA_C674X:
14453           printf ("C674x\n");
14454           break;
14455         default:
14456           printf ("??? (%d)\n", val);
14457           break;
14458         }
14459       return p;
14460
14461     case Tag_ABI_wchar_t:
14462       val = read_uleb128 (p, &len, end);
14463       p += len;
14464       printf ("  Tag_ABI_wchar_t: ");
14465       switch (val)
14466         {
14467         case 0:
14468           printf (_("Not used\n"));
14469           break;
14470         case 1:
14471           printf (_("2 bytes\n"));
14472           break;
14473         case 2:
14474           printf (_("4 bytes\n"));
14475           break;
14476         default:
14477           printf ("??? (%d)\n", val);
14478           break;
14479         }
14480       return p;
14481
14482     case Tag_ABI_stack_align_needed:
14483       val = read_uleb128 (p, &len, end);
14484       p += len;
14485       printf ("  Tag_ABI_stack_align_needed: ");
14486       switch (val)
14487         {
14488         case 0:
14489           printf (_("8-byte\n"));
14490           break;
14491         case 1:
14492           printf (_("16-byte\n"));
14493           break;
14494         default:
14495           printf ("??? (%d)\n", val);
14496           break;
14497         }
14498       return p;
14499
14500     case Tag_ABI_stack_align_preserved:
14501       val = read_uleb128 (p, &len, end);
14502       p += len;
14503       printf ("  Tag_ABI_stack_align_preserved: ");
14504       switch (val)
14505         {
14506         case 0:
14507           printf (_("8-byte\n"));
14508           break;
14509         case 1:
14510           printf (_("16-byte\n"));
14511           break;
14512         default:
14513           printf ("??? (%d)\n", val);
14514           break;
14515         }
14516       return p;
14517
14518     case Tag_ABI_DSBT:
14519       val = read_uleb128 (p, &len, end);
14520       p += len;
14521       printf ("  Tag_ABI_DSBT: ");
14522       switch (val)
14523         {
14524         case 0:
14525           printf (_("DSBT addressing not used\n"));
14526           break;
14527         case 1:
14528           printf (_("DSBT addressing used\n"));
14529           break;
14530         default:
14531           printf ("??? (%d)\n", val);
14532           break;
14533         }
14534       return p;
14535
14536     case Tag_ABI_PID:
14537       val = read_uleb128 (p, &len, end);
14538       p += len;
14539       printf ("  Tag_ABI_PID: ");
14540       switch (val)
14541         {
14542         case 0:
14543           printf (_("Data addressing position-dependent\n"));
14544           break;
14545         case 1:
14546           printf (_("Data addressing position-independent, GOT near DP\n"));
14547           break;
14548         case 2:
14549           printf (_("Data addressing position-independent, GOT far from DP\n"));
14550           break;
14551         default:
14552           printf ("??? (%d)\n", val);
14553           break;
14554         }
14555       return p;
14556
14557     case Tag_ABI_PIC:
14558       val = read_uleb128 (p, &len, end);
14559       p += len;
14560       printf ("  Tag_ABI_PIC: ");
14561       switch (val)
14562         {
14563         case 0:
14564           printf (_("Code addressing position-dependent\n"));
14565           break;
14566         case 1:
14567           printf (_("Code addressing position-independent\n"));
14568           break;
14569         default:
14570           printf ("??? (%d)\n", val);
14571           break;
14572         }
14573       return p;
14574
14575     case Tag_ABI_array_object_alignment:
14576       val = read_uleb128 (p, &len, end);
14577       p += len;
14578       printf ("  Tag_ABI_array_object_alignment: ");
14579       switch (val)
14580         {
14581         case 0:
14582           printf (_("8-byte\n"));
14583           break;
14584         case 1:
14585           printf (_("4-byte\n"));
14586           break;
14587         case 2:
14588           printf (_("16-byte\n"));
14589           break;
14590         default:
14591           printf ("??? (%d)\n", val);
14592           break;
14593         }
14594       return p;
14595
14596     case Tag_ABI_array_object_align_expected:
14597       val = read_uleb128 (p, &len, end);
14598       p += len;
14599       printf ("  Tag_ABI_array_object_align_expected: ");
14600       switch (val)
14601         {
14602         case 0:
14603           printf (_("8-byte\n"));
14604           break;
14605         case 1:
14606           printf (_("4-byte\n"));
14607           break;
14608         case 2:
14609           printf (_("16-byte\n"));
14610           break;
14611         default:
14612           printf ("??? (%d)\n", val);
14613           break;
14614         }
14615       return p;
14616
14617     case Tag_ABI_compatibility:
14618       {
14619         val = read_uleb128 (p, &len, end);
14620         p += len;
14621         printf ("  Tag_ABI_compatibility: ");
14622         printf (_("flag = %d, vendor = "), val);
14623         if (p < end - 1)
14624           {
14625             size_t maxlen = (end - p) - 1;
14626
14627             print_symbol ((int) maxlen, (const char *) p);
14628             p += strnlen ((char *) p, maxlen) + 1;
14629           }
14630         else
14631           {
14632             printf (_("<corrupt>"));
14633             p = (unsigned char *) end;
14634           }
14635         putchar ('\n');
14636         return p;
14637       }
14638
14639     case Tag_ABI_conformance:
14640       {
14641         printf ("  Tag_ABI_conformance: \"");
14642         if (p < end - 1)
14643           {
14644             size_t maxlen = (end - p) - 1;
14645
14646             print_symbol ((int) maxlen, (const char *) p);
14647             p += strnlen ((char *) p, maxlen) + 1;
14648           }
14649         else
14650           {
14651             printf (_("<corrupt>"));
14652             p = (unsigned char *) end;
14653           }
14654         printf ("\"\n");
14655         return p;
14656       }
14657     }
14658
14659   return display_tag_value (tag, p, end);
14660 }
14661
14662 static void
14663 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14664 {
14665   unsigned long addr = 0;
14666   size_t bytes = end - p;
14667
14668   assert (end > p);
14669   while (bytes)
14670     {
14671       int j;
14672       int k;
14673       int lbytes = (bytes > 16 ? 16 : bytes);
14674
14675       printf ("  0x%8.8lx ", addr);
14676
14677       for (j = 0; j < 16; j++)
14678         {
14679           if (j < lbytes)
14680             printf ("%2.2x", p[j]);
14681           else
14682             printf ("  ");
14683
14684           if ((j & 3) == 3)
14685             printf (" ");
14686         }
14687
14688       for (j = 0; j < lbytes; j++)
14689         {
14690           k = p[j];
14691           if (k >= ' ' && k < 0x7f)
14692             printf ("%c", k);
14693           else
14694             printf (".");
14695         }
14696
14697       putchar ('\n');
14698
14699       p  += lbytes;
14700       bytes -= lbytes;
14701       addr += lbytes;
14702     }
14703
14704   putchar ('\n');
14705 }
14706
14707 static unsigned char *
14708 display_msp430x_attribute (unsigned char * p,
14709                            const unsigned char * const end)
14710 {
14711   unsigned int len;
14712   unsigned int val;
14713   unsigned int tag;
14714
14715   tag = read_uleb128 (p, & len, end);
14716   p += len;
14717
14718   switch (tag)
14719     {
14720     case OFBA_MSPABI_Tag_ISA:
14721       val = read_uleb128 (p, &len, end);
14722       p += len;
14723       printf ("  Tag_ISA: ");
14724       switch (val)
14725         {
14726         case 0: printf (_("None\n")); break;
14727         case 1: printf (_("MSP430\n")); break;
14728         case 2: printf (_("MSP430X\n")); break;
14729         default: printf ("??? (%d)\n", val); break;
14730         }
14731       break;
14732
14733     case OFBA_MSPABI_Tag_Code_Model:
14734       val = read_uleb128 (p, &len, end);
14735       p += len;
14736       printf ("  Tag_Code_Model: ");
14737       switch (val)
14738         {
14739         case 0: printf (_("None\n")); break;
14740         case 1: printf (_("Small\n")); break;
14741         case 2: printf (_("Large\n")); break;
14742         default: printf ("??? (%d)\n", val); break;
14743         }
14744       break;
14745
14746     case OFBA_MSPABI_Tag_Data_Model:
14747       val = read_uleb128 (p, &len, end);
14748       p += len;
14749       printf ("  Tag_Data_Model: ");
14750       switch (val)
14751         {
14752         case 0: printf (_("None\n")); break;
14753         case 1: printf (_("Small\n")); break;
14754         case 2: printf (_("Large\n")); break;
14755         case 3: printf (_("Restricted Large\n")); break;
14756         default: printf ("??? (%d)\n", val); break;
14757         }
14758       break;
14759
14760     default:
14761       printf (_("  <unknown tag %d>: "), tag);
14762
14763       if (tag & 1)
14764         {
14765           putchar ('"');
14766           if (p < end - 1)
14767             {
14768               size_t maxlen = (end - p) - 1;
14769
14770               print_symbol ((int) maxlen, (const char *) p);
14771               p += strnlen ((char *) p, maxlen) + 1;
14772             }
14773           else
14774             {
14775               printf (_("<corrupt>"));
14776               p = (unsigned char *) end;
14777             }
14778           printf ("\"\n");
14779         }
14780       else
14781         {
14782           val = read_uleb128 (p, &len, end);
14783           p += len;
14784           printf ("%d (0x%x)\n", val, val);
14785         }
14786       break;
14787    }
14788
14789   assert (p <= end);
14790   return p;
14791 }
14792
14793 static bfd_boolean
14794 process_attributes (FILE * file,
14795                     const char * public_name,
14796                     unsigned int proc_type,
14797                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14798                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14799 {
14800   Elf_Internal_Shdr * sect;
14801   unsigned i;
14802   bfd_boolean res = TRUE;
14803
14804   /* Find the section header so that we get the size.  */
14805   for (i = 0, sect = section_headers;
14806        i < elf_header.e_shnum;
14807        i++, sect++)
14808     {
14809       unsigned char * contents;
14810       unsigned char * p;
14811
14812       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14813         continue;
14814
14815       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14816                                              sect->sh_size, _("attributes"));
14817       if (contents == NULL)
14818         {
14819           res = FALSE;
14820           continue;
14821         }
14822
14823       p = contents;
14824       /* The first character is the version of the attributes.
14825          Currently only version 1, (aka 'A') is recognised here.  */
14826       if (*p != 'A')
14827         {
14828           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14829           res = FALSE;
14830         }
14831       else
14832         {
14833           bfd_vma section_len;
14834
14835           section_len = sect->sh_size - 1;
14836           p++;
14837
14838           while (section_len > 0)
14839             {
14840               bfd_vma attr_len;
14841               unsigned int namelen;
14842               bfd_boolean public_section;
14843               bfd_boolean gnu_section;
14844
14845               if (section_len <= 4)
14846                 {
14847                   error (_("Tag section ends prematurely\n"));
14848                   res = FALSE;
14849                   break;
14850                 }
14851               attr_len = byte_get (p, 4);
14852               p += 4;
14853
14854               if (attr_len > section_len)
14855                 {
14856                   error (_("Bad attribute length (%u > %u)\n"),
14857                           (unsigned) attr_len, (unsigned) section_len);
14858                   attr_len = section_len;
14859                   res = FALSE;
14860                 }
14861               /* PR 17531: file: 001-101425-0.004  */
14862               else if (attr_len < 5)
14863                 {
14864                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14865                   res = FALSE;
14866                   break;
14867                 }
14868
14869               section_len -= attr_len;
14870               attr_len -= 4;
14871
14872               namelen = strnlen ((char *) p, attr_len) + 1;
14873               if (namelen == 0 || namelen >= attr_len)
14874                 {
14875                   error (_("Corrupt attribute section name\n"));
14876                   res = FALSE;
14877                   break;
14878                 }
14879
14880               printf (_("Attribute Section: "));
14881               print_symbol (INT_MAX, (const char *) p);
14882               putchar ('\n');
14883
14884               if (public_name && streq ((char *) p, public_name))
14885                 public_section = TRUE;
14886               else
14887                 public_section = FALSE;
14888
14889               if (streq ((char *) p, "gnu"))
14890                 gnu_section = TRUE;
14891               else
14892                 gnu_section = FALSE;
14893
14894               p += namelen;
14895               attr_len -= namelen;
14896
14897               while (attr_len > 0 && p < contents + sect->sh_size)
14898                 {
14899                   int tag;
14900                   int val;
14901                   bfd_vma size;
14902                   unsigned char * end;
14903
14904                   /* PR binutils/17531: Safe handling of corrupt files.  */
14905                   if (attr_len < 6)
14906                     {
14907                       error (_("Unused bytes at end of section\n"));
14908                       res = FALSE;
14909                       section_len = 0;
14910                       break;
14911                     }
14912
14913                   tag = *(p++);
14914                   size = byte_get (p, 4);
14915                   if (size > attr_len)
14916                     {
14917                       error (_("Bad subsection length (%u > %u)\n"),
14918                               (unsigned) size, (unsigned) attr_len);
14919                       res = FALSE;
14920                       size = attr_len;
14921                     }
14922                   /* PR binutils/17531: Safe handling of corrupt files.  */
14923                   if (size < 6)
14924                     {
14925                       error (_("Bad subsection length (%u < 6)\n"),
14926                               (unsigned) size);
14927                       res = FALSE;
14928                       section_len = 0;
14929                       break;
14930                     }
14931
14932                   attr_len -= size;
14933                   end = p + size - 1;
14934                   assert (end <= contents + sect->sh_size);
14935                   p += 4;
14936
14937                   switch (tag)
14938                     {
14939                     case 1:
14940                       printf (_("File Attributes\n"));
14941                       break;
14942                     case 2:
14943                       printf (_("Section Attributes:"));
14944                       goto do_numlist;
14945                     case 3:
14946                       printf (_("Symbol Attributes:"));
14947                       /* Fall through.  */
14948                     do_numlist:
14949                       for (;;)
14950                         {
14951                           unsigned int j;
14952
14953                           val = read_uleb128 (p, &j, end);
14954                           p += j;
14955                           if (val == 0)
14956                             break;
14957                           printf (" %d", val);
14958                         }
14959                       printf ("\n");
14960                       break;
14961                     default:
14962                       printf (_("Unknown tag: %d\n"), tag);
14963                       public_section = FALSE;
14964                       break;
14965                     }
14966
14967                   if (public_section && display_pub_attribute != NULL)
14968                     {
14969                       while (p < end)
14970                         p = display_pub_attribute (p, end);
14971                       assert (p == end);
14972                     }
14973                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14974                     {
14975                       while (p < end)
14976                         p = display_gnu_attribute (p,
14977                                                    display_proc_gnu_attribute,
14978                                                    end);
14979                       assert (p == end);
14980                     }
14981                   else if (p < end)
14982                     {
14983                       printf (_("  Unknown attribute:\n"));
14984                       display_raw_attribute (p, end);
14985                       p = end;
14986                     }
14987                   else
14988                     attr_len = 0;
14989                 }
14990             }
14991         }
14992
14993       free (contents);
14994     }
14995
14996   return res;
14997 }
14998
14999 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15000    Print the Address, Access and Initial fields of an entry at VMA ADDR
15001    and return the VMA of the next entry, or -1 if there was a problem.
15002    Does not read from DATA_END or beyond.  */
15003
15004 static bfd_vma
15005 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15006                       unsigned char * data_end)
15007 {
15008   printf ("  ");
15009   print_vma (addr, LONG_HEX);
15010   printf (" ");
15011   if (addr < pltgot + 0xfff0)
15012     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15013   else
15014     printf ("%10s", "");
15015   printf (" ");
15016   if (data == NULL)
15017     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15018   else
15019     {
15020       bfd_vma entry;
15021       unsigned char * from = data + addr - pltgot;
15022
15023       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15024         {
15025           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15026           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15027           return (bfd_vma) -1;
15028         }
15029       else
15030         {
15031           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15032           print_vma (entry, LONG_HEX);
15033         }
15034     }
15035   return addr + (is_32bit_elf ? 4 : 8);
15036 }
15037
15038 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15039    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15040    ADDR and return the VMA of the next entry.  */
15041
15042 static bfd_vma
15043 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15044 {
15045   printf ("  ");
15046   print_vma (addr, LONG_HEX);
15047   printf (" ");
15048   if (data == NULL)
15049     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15050   else
15051     {
15052       bfd_vma entry;
15053
15054       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15055       print_vma (entry, LONG_HEX);
15056     }
15057   return addr + (is_32bit_elf ? 4 : 8);
15058 }
15059
15060 static void
15061 print_mips_ases (unsigned int mask)
15062 {
15063   if (mask & AFL_ASE_DSP)
15064     fputs ("\n\tDSP ASE", stdout);
15065   if (mask & AFL_ASE_DSPR2)
15066     fputs ("\n\tDSP R2 ASE", stdout);
15067   if (mask & AFL_ASE_DSPR3)
15068     fputs ("\n\tDSP R3 ASE", stdout);
15069   if (mask & AFL_ASE_EVA)
15070     fputs ("\n\tEnhanced VA Scheme", stdout);
15071   if (mask & AFL_ASE_MCU)
15072     fputs ("\n\tMCU (MicroController) ASE", stdout);
15073   if (mask & AFL_ASE_MDMX)
15074     fputs ("\n\tMDMX ASE", stdout);
15075   if (mask & AFL_ASE_MIPS3D)
15076     fputs ("\n\tMIPS-3D ASE", stdout);
15077   if (mask & AFL_ASE_MT)
15078     fputs ("\n\tMT ASE", stdout);
15079   if (mask & AFL_ASE_SMARTMIPS)
15080     fputs ("\n\tSmartMIPS ASE", stdout);
15081   if (mask & AFL_ASE_VIRT)
15082     fputs ("\n\tVZ ASE", stdout);
15083   if (mask & AFL_ASE_MSA)
15084     fputs ("\n\tMSA ASE", stdout);
15085   if (mask & AFL_ASE_MIPS16)
15086     fputs ("\n\tMIPS16 ASE", stdout);
15087   if (mask & AFL_ASE_MICROMIPS)
15088     fputs ("\n\tMICROMIPS ASE", stdout);
15089   if (mask & AFL_ASE_XPA)
15090     fputs ("\n\tXPA ASE", stdout);
15091   if (mask & AFL_ASE_MIPS16E2)
15092     fputs ("\n\tMIPS16e2 ASE", stdout);
15093   if (mask == 0)
15094     fprintf (stdout, "\n\t%s", _("None"));
15095   else if ((mask & ~AFL_ASE_MASK) != 0)
15096     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15097 }
15098
15099 static void
15100 print_mips_isa_ext (unsigned int isa_ext)
15101 {
15102   switch (isa_ext)
15103     {
15104     case 0:
15105       fputs (_("None"), stdout);
15106       break;
15107     case AFL_EXT_XLR:
15108       fputs ("RMI XLR", stdout);
15109       break;
15110     case AFL_EXT_OCTEON3:
15111       fputs ("Cavium Networks Octeon3", stdout);
15112       break;
15113     case AFL_EXT_OCTEON2:
15114       fputs ("Cavium Networks Octeon2", stdout);
15115       break;
15116     case AFL_EXT_OCTEONP:
15117       fputs ("Cavium Networks OcteonP", stdout);
15118       break;
15119     case AFL_EXT_LOONGSON_3A:
15120       fputs ("Loongson 3A", stdout);
15121       break;
15122     case AFL_EXT_OCTEON:
15123       fputs ("Cavium Networks Octeon", stdout);
15124       break;
15125     case AFL_EXT_5900:
15126       fputs ("Toshiba R5900", stdout);
15127       break;
15128     case AFL_EXT_4650:
15129       fputs ("MIPS R4650", stdout);
15130       break;
15131     case AFL_EXT_4010:
15132       fputs ("LSI R4010", stdout);
15133       break;
15134     case AFL_EXT_4100:
15135       fputs ("NEC VR4100", stdout);
15136       break;
15137     case AFL_EXT_3900:
15138       fputs ("Toshiba R3900", stdout);
15139       break;
15140     case AFL_EXT_10000:
15141       fputs ("MIPS R10000", stdout);
15142       break;
15143     case AFL_EXT_SB1:
15144       fputs ("Broadcom SB-1", stdout);
15145       break;
15146     case AFL_EXT_4111:
15147       fputs ("NEC VR4111/VR4181", stdout);
15148       break;
15149     case AFL_EXT_4120:
15150       fputs ("NEC VR4120", stdout);
15151       break;
15152     case AFL_EXT_5400:
15153       fputs ("NEC VR5400", stdout);
15154       break;
15155     case AFL_EXT_5500:
15156       fputs ("NEC VR5500", stdout);
15157       break;
15158     case AFL_EXT_LOONGSON_2E:
15159       fputs ("ST Microelectronics Loongson 2E", stdout);
15160       break;
15161     case AFL_EXT_LOONGSON_2F:
15162       fputs ("ST Microelectronics Loongson 2F", stdout);
15163       break;
15164     case AFL_EXT_INTERAPTIV_MR2:
15165       fputs ("Imagination interAptiv MR2", stdout);
15166       break;
15167     default:
15168       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15169     }
15170 }
15171
15172 static signed int
15173 get_mips_reg_size (int reg_size)
15174 {
15175   return (reg_size == AFL_REG_NONE) ? 0
15176          : (reg_size == AFL_REG_32) ? 32
15177          : (reg_size == AFL_REG_64) ? 64
15178          : (reg_size == AFL_REG_128) ? 128
15179          : -1;
15180 }
15181
15182 static bfd_boolean
15183 process_mips_specific (FILE * file)
15184 {
15185   Elf_Internal_Dyn * entry;
15186   Elf_Internal_Shdr *sect = NULL;
15187   size_t liblist_offset = 0;
15188   size_t liblistno = 0;
15189   size_t conflictsno = 0;
15190   size_t options_offset = 0;
15191   size_t conflicts_offset = 0;
15192   size_t pltrelsz = 0;
15193   size_t pltrel = 0;
15194   bfd_vma pltgot = 0;
15195   bfd_vma mips_pltgot = 0;
15196   bfd_vma jmprel = 0;
15197   bfd_vma local_gotno = 0;
15198   bfd_vma gotsym = 0;
15199   bfd_vma symtabno = 0;
15200   bfd_boolean res = TRUE;
15201
15202   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15203                             display_mips_gnu_attribute))
15204     res = FALSE;
15205
15206   sect = find_section (".MIPS.abiflags");
15207
15208   if (sect != NULL)
15209     {
15210       Elf_External_ABIFlags_v0 *abiflags_ext;
15211       Elf_Internal_ABIFlags_v0 abiflags_in;
15212
15213       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15214         {
15215           error (_("Corrupt MIPS ABI Flags section.\n"));
15216           res = FALSE;
15217         }
15218       else
15219         {
15220           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15221                                    sect->sh_size, _("MIPS ABI Flags section"));
15222           if (abiflags_ext)
15223             {
15224               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15225               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15226               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15227               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15228               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15229               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15230               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15231               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15232               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15233               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15234               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15235
15236               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15237               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15238               if (abiflags_in.isa_rev > 1)
15239                 printf ("r%d", abiflags_in.isa_rev);
15240               printf ("\nGPR size: %d",
15241                       get_mips_reg_size (abiflags_in.gpr_size));
15242               printf ("\nCPR1 size: %d",
15243                       get_mips_reg_size (abiflags_in.cpr1_size));
15244               printf ("\nCPR2 size: %d",
15245                       get_mips_reg_size (abiflags_in.cpr2_size));
15246               fputs ("\nFP ABI: ", stdout);
15247               print_mips_fp_abi_value (abiflags_in.fp_abi);
15248               fputs ("ISA Extension: ", stdout);
15249               print_mips_isa_ext (abiflags_in.isa_ext);
15250               fputs ("\nASEs:", stdout);
15251               print_mips_ases (abiflags_in.ases);
15252               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15253               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15254               fputc ('\n', stdout);
15255               free (abiflags_ext);
15256             }
15257         }
15258     }
15259
15260   /* We have a lot of special sections.  Thanks SGI!  */
15261   if (dynamic_section == NULL)
15262     {
15263       /* No dynamic information available.  See if there is static GOT.  */
15264       sect = find_section (".got");
15265       if (sect != NULL)
15266         {
15267           unsigned char *data_end;
15268           unsigned char *data;
15269           bfd_vma ent, end;
15270           int addr_size;
15271
15272           pltgot = sect->sh_addr;
15273
15274           ent = pltgot;
15275           addr_size = (is_32bit_elf ? 4 : 8);
15276           end = pltgot + sect->sh_size;
15277
15278           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15279                                              end - pltgot, 1,
15280                                              _("Global Offset Table data"));
15281           /* PR 12855: Null data is handled gracefully throughout.  */
15282           data_end = data + (end - pltgot);
15283
15284           printf (_("\nStatic GOT:\n"));
15285           printf (_(" Canonical gp value: "));
15286           print_vma (ent + 0x7ff0, LONG_HEX);
15287           printf ("\n\n");
15288
15289           /* In a dynamic binary GOT[0] is reserved for the dynamic
15290              loader to store the lazy resolver pointer, however in
15291              a static binary it may well have been omitted and GOT
15292              reduced to a table of addresses.
15293              PR 21344: Check for the entry being fully available
15294              before fetching it.  */
15295           if (data
15296               && data + ent - pltgot + addr_size <= data_end
15297               && byte_get (data + ent - pltgot, addr_size) == 0)
15298             {
15299               printf (_(" Reserved entries:\n"));
15300               printf (_("  %*s %10s %*s\n"),
15301                       addr_size * 2, _("Address"), _("Access"),
15302                       addr_size * 2, _("Value"));
15303               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15304               printf ("\n");
15305               if (ent == (bfd_vma) -1)
15306                 goto sgot_print_fail;
15307
15308               /* Check for the MSB of GOT[1] being set, identifying a
15309                  GNU object.  This entry will be used by some runtime
15310                  loaders, to store the module pointer.  Otherwise this
15311                  is an ordinary local entry.
15312                  PR 21344: Check for the entry being fully available
15313                  before fetching it.  */
15314               if (data
15315                   && data + ent - pltgot + addr_size <= data_end
15316                   && (byte_get (data + ent - pltgot, addr_size)
15317                       >> (addr_size * 8 - 1)) != 0)
15318                 {
15319                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15320                   printf ("\n");
15321                   if (ent == (bfd_vma) -1)
15322                     goto sgot_print_fail;
15323                 }
15324               printf ("\n");
15325             }
15326
15327           if (ent < end)
15328             {
15329               printf (_(" Local entries:\n"));
15330               printf ("  %*s %10s %*s\n",
15331                       addr_size * 2, _("Address"), _("Access"),
15332                       addr_size * 2, _("Value"));
15333               while (ent < end)
15334                 {
15335                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15336                   printf ("\n");
15337                   if (ent == (bfd_vma) -1)
15338                     goto sgot_print_fail;
15339                 }
15340               printf ("\n");
15341             }
15342
15343         sgot_print_fail:
15344           if (data)
15345             free (data);
15346         }
15347       return res;
15348     }
15349
15350   for (entry = dynamic_section;
15351        /* PR 17531 file: 012-50589-0.004.  */
15352        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15353        ++entry)
15354     switch (entry->d_tag)
15355       {
15356       case DT_MIPS_LIBLIST:
15357         liblist_offset
15358           = offset_from_vma (file, entry->d_un.d_val,
15359                              liblistno * sizeof (Elf32_External_Lib));
15360         break;
15361       case DT_MIPS_LIBLISTNO:
15362         liblistno = entry->d_un.d_val;
15363         break;
15364       case DT_MIPS_OPTIONS:
15365         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15366         break;
15367       case DT_MIPS_CONFLICT:
15368         conflicts_offset
15369           = offset_from_vma (file, entry->d_un.d_val,
15370                              conflictsno * sizeof (Elf32_External_Conflict));
15371         break;
15372       case DT_MIPS_CONFLICTNO:
15373         conflictsno = entry->d_un.d_val;
15374         break;
15375       case DT_PLTGOT:
15376         pltgot = entry->d_un.d_ptr;
15377         break;
15378       case DT_MIPS_LOCAL_GOTNO:
15379         local_gotno = entry->d_un.d_val;
15380         break;
15381       case DT_MIPS_GOTSYM:
15382         gotsym = entry->d_un.d_val;
15383         break;
15384       case DT_MIPS_SYMTABNO:
15385         symtabno = entry->d_un.d_val;
15386         break;
15387       case DT_MIPS_PLTGOT:
15388         mips_pltgot = entry->d_un.d_ptr;
15389         break;
15390       case DT_PLTREL:
15391         pltrel = entry->d_un.d_val;
15392         break;
15393       case DT_PLTRELSZ:
15394         pltrelsz = entry->d_un.d_val;
15395         break;
15396       case DT_JMPREL:
15397         jmprel = entry->d_un.d_ptr;
15398         break;
15399       default:
15400         break;
15401       }
15402
15403   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15404     {
15405       Elf32_External_Lib * elib;
15406       size_t cnt;
15407
15408       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15409                                               liblistno,
15410                                               sizeof (Elf32_External_Lib),
15411                                               _("liblist section data"));
15412       if (elib)
15413         {
15414           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15415                   (unsigned long) liblistno);
15416           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15417                  stdout);
15418
15419           for (cnt = 0; cnt < liblistno; ++cnt)
15420             {
15421               Elf32_Lib liblist;
15422               time_t atime;
15423               char timebuf[128];
15424               struct tm * tmp;
15425
15426               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15427               atime = BYTE_GET (elib[cnt].l_time_stamp);
15428               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15429               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15430               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15431
15432               tmp = gmtime (&atime);
15433               snprintf (timebuf, sizeof (timebuf),
15434                         "%04u-%02u-%02uT%02u:%02u:%02u",
15435                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15436                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15437
15438               printf ("%3lu: ", (unsigned long) cnt);
15439               if (VALID_DYNAMIC_NAME (liblist.l_name))
15440                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15441               else
15442                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15443               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15444                       liblist.l_version);
15445
15446               if (liblist.l_flags == 0)
15447                 puts (_(" NONE"));
15448               else
15449                 {
15450                   static const struct
15451                   {
15452                     const char * name;
15453                     int bit;
15454                   }
15455                   l_flags_vals[] =
15456                   {
15457                     { " EXACT_MATCH", LL_EXACT_MATCH },
15458                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15459                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15460                     { " EXPORTS", LL_EXPORTS },
15461                     { " DELAY_LOAD", LL_DELAY_LOAD },
15462                     { " DELTA", LL_DELTA }
15463                   };
15464                   int flags = liblist.l_flags;
15465                   size_t fcnt;
15466
15467                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15468                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15469                       {
15470                         fputs (l_flags_vals[fcnt].name, stdout);
15471                         flags ^= l_flags_vals[fcnt].bit;
15472                       }
15473                   if (flags != 0)
15474                     printf (" %#x", (unsigned int) flags);
15475
15476                   puts ("");
15477                 }
15478             }
15479
15480           free (elib);
15481         }
15482       else
15483         res = FALSE;
15484     }
15485
15486   if (options_offset != 0)
15487     {
15488       Elf_External_Options * eopt;
15489       Elf_Internal_Options * iopt;
15490       Elf_Internal_Options * option;
15491       size_t offset;
15492       int cnt;
15493       sect = section_headers;
15494
15495       /* Find the section header so that we get the size.  */
15496       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15497       /* PR 17533 file: 012-277276-0.004.  */
15498       if (sect == NULL)
15499         {
15500           error (_("No MIPS_OPTIONS header found\n"));
15501           return FALSE;
15502         }
15503
15504       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15505                                                 sect->sh_size, _("options"));
15506       if (eopt)
15507         {
15508           iopt = (Elf_Internal_Options *)
15509               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15510           if (iopt == NULL)
15511             {
15512               error (_("Out of memory allocating space for MIPS options\n"));
15513               return FALSE;
15514             }
15515
15516           offset = cnt = 0;
15517           option = iopt;
15518
15519           while (offset <= sect->sh_size - sizeof (* eopt))
15520             {
15521               Elf_External_Options * eoption;
15522
15523               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15524
15525               option->kind = BYTE_GET (eoption->kind);
15526               option->size = BYTE_GET (eoption->size);
15527               option->section = BYTE_GET (eoption->section);
15528               option->info = BYTE_GET (eoption->info);
15529
15530               /* PR 17531: file: ffa0fa3b.  */
15531               if (option->size < sizeof (* eopt)
15532                   || offset + option->size > sect->sh_size)
15533                 {
15534                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15535                   return FALSE;
15536                 }
15537               offset += option->size;
15538
15539               ++option;
15540               ++cnt;
15541             }
15542
15543           printf (_("\nSection '%s' contains %d entries:\n"),
15544                   printable_section_name (sect), cnt);
15545
15546           option = iopt;
15547           offset = 0;
15548
15549           while (cnt-- > 0)
15550             {
15551               size_t len;
15552
15553               switch (option->kind)
15554                 {
15555                 case ODK_NULL:
15556                   /* This shouldn't happen.  */
15557                   printf (" NULL       %d %lx", option->section, option->info);
15558                   break;
15559                 case ODK_REGINFO:
15560                   printf (" REGINFO    ");
15561                   if (elf_header.e_machine == EM_MIPS)
15562                     {
15563                       /* 32bit form.  */
15564                       Elf32_External_RegInfo * ereg;
15565                       Elf32_RegInfo reginfo;
15566
15567                       ereg = (Elf32_External_RegInfo *) (option + 1);
15568                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15569                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15570                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15571                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15572                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15573                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15574
15575                       printf ("GPR %08lx  GP 0x%lx\n",
15576                               reginfo.ri_gprmask,
15577                               (unsigned long) reginfo.ri_gp_value);
15578                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15579                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15580                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15581                     }
15582                   else
15583                     {
15584                       /* 64 bit form.  */
15585                       Elf64_External_RegInfo * ereg;
15586                       Elf64_Internal_RegInfo reginfo;
15587
15588                       ereg = (Elf64_External_RegInfo *) (option + 1);
15589                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15590                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15591                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15592                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15593                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15594                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15595
15596                       printf ("GPR %08lx  GP 0x",
15597                               reginfo.ri_gprmask);
15598                       printf_vma (reginfo.ri_gp_value);
15599                       printf ("\n");
15600
15601                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15602                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15603                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15604                     }
15605                   ++option;
15606                   continue;
15607                 case ODK_EXCEPTIONS:
15608                   fputs (" EXCEPTIONS fpe_min(", stdout);
15609                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15610                   fputs (") fpe_max(", stdout);
15611                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15612                   fputs (")", stdout);
15613
15614                   if (option->info & OEX_PAGE0)
15615                     fputs (" PAGE0", stdout);
15616                   if (option->info & OEX_SMM)
15617                     fputs (" SMM", stdout);
15618                   if (option->info & OEX_FPDBUG)
15619                     fputs (" FPDBUG", stdout);
15620                   if (option->info & OEX_DISMISS)
15621                     fputs (" DISMISS", stdout);
15622                   break;
15623                 case ODK_PAD:
15624                   fputs (" PAD       ", stdout);
15625                   if (option->info & OPAD_PREFIX)
15626                     fputs (" PREFIX", stdout);
15627                   if (option->info & OPAD_POSTFIX)
15628                     fputs (" POSTFIX", stdout);
15629                   if (option->info & OPAD_SYMBOL)
15630                     fputs (" SYMBOL", stdout);
15631                   break;
15632                 case ODK_HWPATCH:
15633                   fputs (" HWPATCH   ", stdout);
15634                   if (option->info & OHW_R4KEOP)
15635                     fputs (" R4KEOP", stdout);
15636                   if (option->info & OHW_R8KPFETCH)
15637                     fputs (" R8KPFETCH", stdout);
15638                   if (option->info & OHW_R5KEOP)
15639                     fputs (" R5KEOP", stdout);
15640                   if (option->info & OHW_R5KCVTL)
15641                     fputs (" R5KCVTL", stdout);
15642                   break;
15643                 case ODK_FILL:
15644                   fputs (" FILL       ", stdout);
15645                   /* XXX Print content of info word?  */
15646                   break;
15647                 case ODK_TAGS:
15648                   fputs (" TAGS       ", stdout);
15649                   /* XXX Print content of info word?  */
15650                   break;
15651                 case ODK_HWAND:
15652                   fputs (" HWAND     ", stdout);
15653                   if (option->info & OHWA0_R4KEOP_CHECKED)
15654                     fputs (" R4KEOP_CHECKED", stdout);
15655                   if (option->info & OHWA0_R4KEOP_CLEAN)
15656                     fputs (" R4KEOP_CLEAN", stdout);
15657                   break;
15658                 case ODK_HWOR:
15659                   fputs (" HWOR      ", stdout);
15660                   if (option->info & OHWA0_R4KEOP_CHECKED)
15661                     fputs (" R4KEOP_CHECKED", stdout);
15662                   if (option->info & OHWA0_R4KEOP_CLEAN)
15663                     fputs (" R4KEOP_CLEAN", stdout);
15664                   break;
15665                 case ODK_GP_GROUP:
15666                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15667                           option->info & OGP_GROUP,
15668                           (option->info & OGP_SELF) >> 16);
15669                   break;
15670                 case ODK_IDENT:
15671                   printf (" IDENT     %#06lx  self-contained %#06lx",
15672                           option->info & OGP_GROUP,
15673                           (option->info & OGP_SELF) >> 16);
15674                   break;
15675                 default:
15676                   /* This shouldn't happen.  */
15677                   printf (" %3d ???     %d %lx",
15678                           option->kind, option->section, option->info);
15679                   break;
15680                 }
15681
15682               len = sizeof (* eopt);
15683               while (len < option->size)
15684                 {
15685                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15686
15687                   if (ISPRINT (datum))
15688                     printf ("%c", datum);
15689                   else
15690                     printf ("\\%03o", datum);
15691                   len ++;
15692                 }
15693               fputs ("\n", stdout);
15694
15695               offset += option->size;
15696               ++option;
15697             }
15698
15699           free (eopt);
15700         }
15701       else
15702         res = FALSE;
15703     }
15704
15705   if (conflicts_offset != 0 && conflictsno != 0)
15706     {
15707       Elf32_Conflict * iconf;
15708       size_t cnt;
15709
15710       if (dynamic_symbols == NULL)
15711         {
15712           error (_("conflict list found without a dynamic symbol table\n"));
15713           return FALSE;
15714         }
15715
15716       /* PR 21345 - print a slightly more helpful error message
15717          if we are sure that the cmalloc will fail.  */
15718       if (conflictsno * sizeof (* iconf) > current_file_size)
15719         {
15720           error (_("Overlarge number of conflicts detected: %lx\n"),
15721                  (long) conflictsno);
15722           return FALSE;
15723         }
15724
15725       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15726       if (iconf == NULL)
15727         {
15728           error (_("Out of memory allocating space for dynamic conflicts\n"));
15729           return FALSE;
15730         }
15731
15732       if (is_32bit_elf)
15733         {
15734           Elf32_External_Conflict * econf32;
15735
15736           econf32 = (Elf32_External_Conflict *)
15737               get_data (NULL, file, conflicts_offset, conflictsno,
15738                         sizeof (* econf32), _("conflict"));
15739           if (!econf32)
15740             return FALSE;
15741
15742           for (cnt = 0; cnt < conflictsno; ++cnt)
15743             iconf[cnt] = BYTE_GET (econf32[cnt]);
15744
15745           free (econf32);
15746         }
15747       else
15748         {
15749           Elf64_External_Conflict * econf64;
15750
15751           econf64 = (Elf64_External_Conflict *)
15752               get_data (NULL, file, conflicts_offset, conflictsno,
15753                         sizeof (* econf64), _("conflict"));
15754           if (!econf64)
15755             return FALSE;
15756
15757           for (cnt = 0; cnt < conflictsno; ++cnt)
15758             iconf[cnt] = BYTE_GET (econf64[cnt]);
15759
15760           free (econf64);
15761         }
15762
15763       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15764               (unsigned long) conflictsno);
15765       puts (_("  Num:    Index       Value  Name"));
15766
15767       for (cnt = 0; cnt < conflictsno; ++cnt)
15768         {
15769           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15770
15771           if (iconf[cnt] >= num_dynamic_syms)
15772             printf (_("<corrupt symbol index>"));
15773           else
15774             {
15775               Elf_Internal_Sym * psym;
15776
15777               psym = & dynamic_symbols[iconf[cnt]];
15778               print_vma (psym->st_value, FULL_HEX);
15779               putchar (' ');
15780               if (VALID_DYNAMIC_NAME (psym->st_name))
15781                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15782               else
15783                 printf (_("<corrupt: %14ld>"), psym->st_name);
15784             }
15785           putchar ('\n');
15786         }
15787
15788       free (iconf);
15789     }
15790
15791   if (pltgot != 0 && local_gotno != 0)
15792     {
15793       bfd_vma ent, local_end, global_end;
15794       size_t i, offset;
15795       unsigned char * data;
15796       unsigned char * data_end;
15797       int addr_size;
15798
15799       ent = pltgot;
15800       addr_size = (is_32bit_elf ? 4 : 8);
15801       local_end = pltgot + local_gotno * addr_size;
15802
15803       /* PR binutils/17533 file: 012-111227-0.004  */
15804       if (symtabno < gotsym)
15805         {
15806           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15807                  (unsigned long) gotsym, (unsigned long) symtabno);
15808           return FALSE;
15809         }
15810
15811       global_end = local_end + (symtabno - gotsym) * addr_size;
15812       /* PR 17531: file: 54c91a34.  */
15813       if (global_end < local_end)
15814         {
15815           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15816           return FALSE;
15817         }
15818
15819       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15820       data = (unsigned char *) get_data (NULL, file, offset,
15821                                          global_end - pltgot, 1,
15822                                          _("Global Offset Table data"));
15823       /* PR 12855: Null data is handled gracefully throughout.  */
15824       data_end = data + (global_end - pltgot);
15825
15826       printf (_("\nPrimary GOT:\n"));
15827       printf (_(" Canonical gp value: "));
15828       print_vma (pltgot + 0x7ff0, LONG_HEX);
15829       printf ("\n\n");
15830
15831       printf (_(" Reserved entries:\n"));
15832       printf (_("  %*s %10s %*s Purpose\n"),
15833               addr_size * 2, _("Address"), _("Access"),
15834               addr_size * 2, _("Initial"));
15835       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15836       printf (_(" Lazy resolver\n"));
15837       if (ent == (bfd_vma) -1)
15838         goto got_print_fail;
15839
15840       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15841          This entry will be used by some runtime loaders, to store the
15842          module pointer.  Otherwise this is an ordinary local entry.
15843          PR 21344: Check for the entry being fully available before
15844          fetching it.  */
15845       if (data
15846           && data + ent - pltgot + addr_size <= data_end
15847           && (byte_get (data + ent - pltgot, addr_size)
15848               >> (addr_size * 8 - 1)) != 0)
15849         {
15850           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15851           printf (_(" Module pointer (GNU extension)\n"));
15852           if (ent == (bfd_vma) -1)
15853             goto got_print_fail;
15854         }
15855       printf ("\n");
15856
15857       if (ent < local_end)
15858         {
15859           printf (_(" Local entries:\n"));
15860           printf ("  %*s %10s %*s\n",
15861                   addr_size * 2, _("Address"), _("Access"),
15862                   addr_size * 2, _("Initial"));
15863           while (ent < local_end)
15864             {
15865               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15866               printf ("\n");
15867               if (ent == (bfd_vma) -1)
15868                 goto got_print_fail;
15869             }
15870           printf ("\n");
15871         }
15872
15873       if (gotsym < symtabno)
15874         {
15875           int sym_width;
15876
15877           printf (_(" Global entries:\n"));
15878           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15879                   addr_size * 2, _("Address"),
15880                   _("Access"),
15881                   addr_size * 2, _("Initial"),
15882                   addr_size * 2, _("Sym.Val."),
15883                   _("Type"),
15884                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15885                   _("Ndx"), _("Name"));
15886
15887           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15888
15889           for (i = gotsym; i < symtabno; i++)
15890             {
15891               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15892               printf (" ");
15893
15894               if (dynamic_symbols == NULL)
15895                 printf (_("<no dynamic symbols>"));
15896               else if (i < num_dynamic_syms)
15897                 {
15898                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15899
15900                   print_vma (psym->st_value, LONG_HEX);
15901                   printf (" %-7s %3s ",
15902                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15903                           get_symbol_index_type (psym->st_shndx));
15904
15905                   if (VALID_DYNAMIC_NAME (psym->st_name))
15906                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15907                   else
15908                     printf (_("<corrupt: %14ld>"), psym->st_name);
15909                 }
15910               else
15911                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15912                         (unsigned long) i);
15913
15914               printf ("\n");
15915               if (ent == (bfd_vma) -1)
15916                 break;
15917             }
15918           printf ("\n");
15919         }
15920
15921     got_print_fail:
15922       if (data)
15923         free (data);
15924     }
15925
15926   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15927     {
15928       bfd_vma ent, end;
15929       size_t offset, rel_offset;
15930       unsigned long count, i;
15931       unsigned char * data;
15932       int addr_size, sym_width;
15933       Elf_Internal_Rela * rels;
15934
15935       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15936       if (pltrel == DT_RELA)
15937         {
15938           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15939             return FALSE;
15940         }
15941       else
15942         {
15943           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15944             return FALSE;
15945         }
15946
15947       ent = mips_pltgot;
15948       addr_size = (is_32bit_elf ? 4 : 8);
15949       end = mips_pltgot + (2 + count) * addr_size;
15950
15951       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15952       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15953                                          1, _("Procedure Linkage Table data"));
15954       if (data == NULL)
15955         return FALSE;
15956
15957       printf ("\nPLT GOT:\n\n");
15958       printf (_(" Reserved entries:\n"));
15959       printf (_("  %*s %*s Purpose\n"),
15960               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15961       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15962       printf (_(" PLT lazy resolver\n"));
15963       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15964       printf (_(" Module pointer\n"));
15965       printf ("\n");
15966
15967       printf (_(" Entries:\n"));
15968       printf ("  %*s %*s %*s %-7s %3s %s\n",
15969               addr_size * 2, _("Address"),
15970               addr_size * 2, _("Initial"),
15971               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15972       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15973       for (i = 0; i < count; i++)
15974         {
15975           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15976
15977           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15978           printf (" ");
15979
15980           if (idx >= num_dynamic_syms)
15981             printf (_("<corrupt symbol index: %lu>"), idx);
15982           else
15983             {
15984               Elf_Internal_Sym * psym = dynamic_symbols + idx;
15985
15986               print_vma (psym->st_value, LONG_HEX);
15987               printf (" %-7s %3s ",
15988                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15989                       get_symbol_index_type (psym->st_shndx));
15990               if (VALID_DYNAMIC_NAME (psym->st_name))
15991                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15992               else
15993                 printf (_("<corrupt: %14ld>"), psym->st_name);
15994             }
15995           printf ("\n");
15996         }
15997       printf ("\n");
15998
15999       if (data)
16000         free (data);
16001       free (rels);
16002     }
16003
16004   return res;
16005 }
16006
16007 static bfd_boolean
16008 process_nds32_specific (FILE * file)
16009 {
16010   Elf_Internal_Shdr *sect = NULL;
16011
16012   sect = find_section (".nds32_e_flags");
16013   if (sect != NULL)
16014     {
16015       unsigned int *flag;
16016
16017       printf ("\nNDS32 elf flags section:\n");
16018       flag = get_data (NULL, file, sect->sh_offset, 1,
16019                        sect->sh_size, _("NDS32 elf flags section"));
16020
16021       if (! flag)
16022         return FALSE;
16023
16024       switch ((*flag) & 0x3)
16025         {
16026         case 0:
16027           printf ("(VEC_SIZE):\tNo entry.\n");
16028           break;
16029         case 1:
16030           printf ("(VEC_SIZE):\t4 bytes\n");
16031           break;
16032         case 2:
16033           printf ("(VEC_SIZE):\t16 bytes\n");
16034           break;
16035         case 3:
16036           printf ("(VEC_SIZE):\treserved\n");
16037           break;
16038         }
16039     }
16040
16041   return TRUE;
16042 }
16043
16044 static bfd_boolean
16045 process_gnu_liblist (FILE * file)
16046 {
16047   Elf_Internal_Shdr * section;
16048   Elf_Internal_Shdr * string_sec;
16049   Elf32_External_Lib * elib;
16050   char * strtab;
16051   size_t strtab_size;
16052   size_t cnt;
16053   unsigned i;
16054   bfd_boolean res = TRUE;
16055
16056   if (! do_arch)
16057     return TRUE;
16058
16059   for (i = 0, section = section_headers;
16060        i < elf_header.e_shnum;
16061        i++, section++)
16062     {
16063       switch (section->sh_type)
16064         {
16065         case SHT_GNU_LIBLIST:
16066           if (section->sh_link >= elf_header.e_shnum)
16067             break;
16068
16069           elib = (Elf32_External_Lib *)
16070               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16071                         _("liblist section data"));
16072
16073           if (elib == NULL)
16074             {
16075               res = FALSE;
16076               break;
16077             }
16078
16079           string_sec = section_headers + section->sh_link;
16080           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16081                                       string_sec->sh_size,
16082                                       _("liblist string table"));
16083           if (strtab == NULL
16084               || section->sh_entsize != sizeof (Elf32_External_Lib))
16085             {
16086               free (elib);
16087               free (strtab);
16088               res = FALSE;
16089               break;
16090             }
16091           strtab_size = string_sec->sh_size;
16092
16093           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16094                   printable_section_name (section),
16095                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16096
16097           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16098
16099           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16100                ++cnt)
16101             {
16102               Elf32_Lib liblist;
16103               time_t atime;
16104               char timebuf[128];
16105               struct tm * tmp;
16106
16107               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16108               atime = BYTE_GET (elib[cnt].l_time_stamp);
16109               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16110               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16111               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16112
16113               tmp = gmtime (&atime);
16114               snprintf (timebuf, sizeof (timebuf),
16115                         "%04u-%02u-%02uT%02u:%02u:%02u",
16116                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16117                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16118
16119               printf ("%3lu: ", (unsigned long) cnt);
16120               if (do_wide)
16121                 printf ("%-20s", liblist.l_name < strtab_size
16122                         ? strtab + liblist.l_name : _("<corrupt>"));
16123               else
16124                 printf ("%-20.20s", liblist.l_name < strtab_size
16125                         ? strtab + liblist.l_name : _("<corrupt>"));
16126               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16127                       liblist.l_version, liblist.l_flags);
16128             }
16129
16130           free (elib);
16131           free (strtab);
16132         }
16133     }
16134
16135   return res;
16136 }
16137
16138 static const char *
16139 get_note_type (unsigned e_type)
16140 {
16141   static char buff[64];
16142
16143   if (elf_header.e_type == ET_CORE)
16144     switch (e_type)
16145       {
16146       case NT_AUXV:
16147         return _("NT_AUXV (auxiliary vector)");
16148       case NT_PRSTATUS:
16149         return _("NT_PRSTATUS (prstatus structure)");
16150       case NT_FPREGSET:
16151         return _("NT_FPREGSET (floating point registers)");
16152       case NT_PRPSINFO:
16153         return _("NT_PRPSINFO (prpsinfo structure)");
16154       case NT_TASKSTRUCT:
16155         return _("NT_TASKSTRUCT (task structure)");
16156       case NT_PRXFPREG:
16157         return _("NT_PRXFPREG (user_xfpregs structure)");
16158       case NT_PPC_VMX:
16159         return _("NT_PPC_VMX (ppc Altivec registers)");
16160       case NT_PPC_VSX:
16161         return _("NT_PPC_VSX (ppc VSX registers)");
16162       case NT_PPC_TAR:
16163         return _("NT_PPC_TAR (ppc TAR register)");
16164       case NT_PPC_PPR:
16165         return _("NT_PPC_PPR (ppc PPR register)");
16166       case NT_PPC_DSCR:
16167         return _("NT_PPC_DSCR (ppc DSCR register)");
16168       case NT_PPC_EBB:
16169         return _("NT_PPC_EBB (ppc EBB registers)");
16170       case NT_PPC_PMU:
16171         return _("NT_PPC_PMU (ppc PMU registers)");
16172       case NT_PPC_TM_CGPR:
16173         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16174       case NT_PPC_TM_CFPR:
16175         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16176       case NT_PPC_TM_CVMX:
16177         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16178       case NT_PPC_TM_CVSX:
16179         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16180       case NT_PPC_TM_SPR:
16181         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16182       case NT_PPC_TM_CTAR:
16183         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16184       case NT_PPC_TM_CPPR:
16185         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16186       case NT_PPC_TM_CDSCR:
16187         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16188       case NT_386_TLS:
16189         return _("NT_386_TLS (x86 TLS information)");
16190       case NT_386_IOPERM:
16191         return _("NT_386_IOPERM (x86 I/O permissions)");
16192       case NT_X86_XSTATE:
16193         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16194       case NT_S390_HIGH_GPRS:
16195         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16196       case NT_S390_TIMER:
16197         return _("NT_S390_TIMER (s390 timer register)");
16198       case NT_S390_TODCMP:
16199         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16200       case NT_S390_TODPREG:
16201         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16202       case NT_S390_CTRS:
16203         return _("NT_S390_CTRS (s390 control registers)");
16204       case NT_S390_PREFIX:
16205         return _("NT_S390_PREFIX (s390 prefix register)");
16206       case NT_S390_LAST_BREAK:
16207         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16208       case NT_S390_SYSTEM_CALL:
16209         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16210       case NT_S390_TDB:
16211         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16212       case NT_S390_VXRS_LOW:
16213         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16214       case NT_S390_VXRS_HIGH:
16215         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16216       case NT_S390_GS_CB:
16217         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16218       case NT_S390_GS_BC:
16219         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16220       case NT_ARM_VFP:
16221         return _("NT_ARM_VFP (arm VFP registers)");
16222       case NT_ARM_TLS:
16223         return _("NT_ARM_TLS (AArch TLS registers)");
16224       case NT_ARM_HW_BREAK:
16225         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16226       case NT_ARM_HW_WATCH:
16227         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16228       case NT_PSTATUS:
16229         return _("NT_PSTATUS (pstatus structure)");
16230       case NT_FPREGS:
16231         return _("NT_FPREGS (floating point registers)");
16232       case NT_PSINFO:
16233         return _("NT_PSINFO (psinfo structure)");
16234       case NT_LWPSTATUS:
16235         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16236       case NT_LWPSINFO:
16237         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16238       case NT_WIN32PSTATUS:
16239         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16240       case NT_SIGINFO:
16241         return _("NT_SIGINFO (siginfo_t data)");
16242       case NT_FILE:
16243         return _("NT_FILE (mapped files)");
16244       default:
16245         break;
16246       }
16247   else
16248     switch (e_type)
16249       {
16250       case NT_VERSION:
16251         return _("NT_VERSION (version)");
16252       case NT_ARCH:
16253         return _("NT_ARCH (architecture)");
16254       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16255         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16256       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16257         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16258       default:
16259         break;
16260       }
16261
16262   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16263   return buff;
16264 }
16265
16266 static bfd_boolean
16267 print_core_note (Elf_Internal_Note *pnote)
16268 {
16269   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16270   bfd_vma count, page_size;
16271   unsigned char *descdata, *filenames, *descend;
16272
16273   if (pnote->type != NT_FILE)
16274     {
16275       if (do_wide)
16276         printf ("\n");
16277       return TRUE;
16278     }
16279
16280 #ifndef BFD64
16281   if (!is_32bit_elf)
16282     {
16283       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16284       /* Still "successful".  */
16285       return TRUE;
16286     }
16287 #endif
16288
16289   if (pnote->descsz < 2 * addr_size)
16290     {
16291       error (_("    Malformed note - too short for header\n"));
16292       return FALSE;
16293     }
16294
16295   descdata = (unsigned char *) pnote->descdata;
16296   descend = descdata + pnote->descsz;
16297
16298   if (descdata[pnote->descsz - 1] != '\0')
16299     {
16300       error (_("    Malformed note - does not end with \\0\n"));
16301       return FALSE;
16302     }
16303
16304   count = byte_get (descdata, addr_size);
16305   descdata += addr_size;
16306
16307   page_size = byte_get (descdata, addr_size);
16308   descdata += addr_size;
16309
16310   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16311     {
16312       error (_("    Malformed note - too short for supplied file count\n"));
16313       return FALSE;
16314     }
16315
16316   printf (_("    Page size: "));
16317   print_vma (page_size, DEC);
16318   printf ("\n");
16319
16320   printf (_("    %*s%*s%*s\n"),
16321           (int) (2 + 2 * addr_size), _("Start"),
16322           (int) (4 + 2 * addr_size), _("End"),
16323           (int) (4 + 2 * addr_size), _("Page Offset"));
16324   filenames = descdata + count * 3 * addr_size;
16325   while (count-- > 0)
16326     {
16327       bfd_vma start, end, file_ofs;
16328
16329       if (filenames == descend)
16330         {
16331           error (_("    Malformed note - filenames end too early\n"));
16332           return FALSE;
16333         }
16334
16335       start = byte_get (descdata, addr_size);
16336       descdata += addr_size;
16337       end = byte_get (descdata, addr_size);
16338       descdata += addr_size;
16339       file_ofs = byte_get (descdata, addr_size);
16340       descdata += addr_size;
16341
16342       printf ("    ");
16343       print_vma (start, FULL_HEX);
16344       printf ("  ");
16345       print_vma (end, FULL_HEX);
16346       printf ("  ");
16347       print_vma (file_ofs, FULL_HEX);
16348       printf ("\n        %s\n", filenames);
16349
16350       filenames += 1 + strlen ((char *) filenames);
16351     }
16352
16353   return TRUE;
16354 }
16355
16356 static const char *
16357 get_gnu_elf_note_type (unsigned e_type)
16358 {
16359   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16360   switch (e_type)
16361     {
16362     case NT_GNU_ABI_TAG:
16363       return _("NT_GNU_ABI_TAG (ABI version tag)");
16364     case NT_GNU_HWCAP:
16365       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16366     case NT_GNU_BUILD_ID:
16367       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16368     case NT_GNU_GOLD_VERSION:
16369       return _("NT_GNU_GOLD_VERSION (gold version)");
16370     case NT_GNU_PROPERTY_TYPE_0:
16371       return _("NT_GNU_PROPERTY_TYPE_0");
16372     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16373       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16374     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16375       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16376     default:
16377       {
16378         static char buff[64];
16379
16380         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16381         return buff;
16382       }
16383     }
16384 }
16385
16386 static void
16387 decode_x86_isa (unsigned int bitmask)
16388 {
16389   while (bitmask)
16390     {
16391       unsigned int bit = bitmask & (- bitmask);
16392
16393       bitmask &= ~ bit;
16394       switch (bit)
16395         {
16396         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16397         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16398         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16399         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16400         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16401         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16402         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16403         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16404         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16405         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16406         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16407         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16408         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16409         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16410         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16411         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16412         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16413         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16414         default: printf (_("<unknown: %x>"), bit); break;
16415         }
16416       if (bitmask)
16417         printf (", ");
16418     }
16419 }
16420
16421 static void
16422 decode_x86_feature (unsigned int type, unsigned int bitmask)
16423 {
16424   while (bitmask)
16425     {
16426       unsigned int bit = bitmask & (- bitmask);
16427
16428       bitmask &= ~ bit;
16429       switch (bit)
16430         {
16431         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16432           switch (type)
16433             {
16434             case GNU_PROPERTY_X86_FEATURE_1_AND:
16435               printf ("IBT");
16436               break;
16437             default:
16438               /* This should never happen.  */
16439               abort ();
16440             }
16441           break;
16442         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16443           switch (type)
16444             {
16445             case GNU_PROPERTY_X86_FEATURE_1_AND:
16446               printf ("SHSTK");
16447               break;
16448             default:
16449               /* This should never happen.  */
16450               abort ();
16451             }
16452           break;
16453         default:
16454           printf (_("<unknown: %x>"), bit);
16455           break;
16456         }
16457       if (bitmask)
16458         printf (", ");
16459     }
16460 }
16461
16462 static void
16463 print_gnu_property_note (Elf_Internal_Note * pnote)
16464 {
16465   unsigned char * ptr = (unsigned char *) pnote->descdata;
16466   unsigned char * ptr_end = ptr + pnote->descsz;
16467   unsigned int    size = is_32bit_elf ? 4 : 8;
16468
16469   printf (_("      Properties: "));
16470
16471   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16472     {
16473       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16474       return;
16475     }
16476
16477   while (1)
16478     {
16479       unsigned int j;
16480       unsigned int type = byte_get (ptr, 4);
16481       unsigned int datasz = byte_get (ptr + 4, 4);
16482
16483       ptr += 8;
16484
16485       if ((ptr + datasz) > ptr_end)
16486         {
16487           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16488                   type, datasz);
16489           break;
16490         }
16491
16492       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16493         {
16494           if (elf_header.e_machine == EM_X86_64
16495               || elf_header.e_machine == EM_IAMCU
16496               || elf_header.e_machine == EM_386)
16497             {
16498               switch (type)
16499                 {
16500                 case GNU_PROPERTY_X86_ISA_1_USED:
16501                   printf ("x86 ISA used: ");
16502                   if (datasz != 4)
16503                     printf (_("<corrupt length: %#x> "), datasz);
16504                   else
16505                     decode_x86_isa (byte_get (ptr, 4));
16506                   goto next;
16507
16508                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16509                   printf ("x86 ISA needed: ");
16510                   if (datasz != 4)
16511                     printf (_("<corrupt length: %#x> "), datasz);
16512                   else
16513                     decode_x86_isa (byte_get (ptr, 4));
16514                   goto next;
16515
16516                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16517                   printf ("x86 feature: ");
16518                   if (datasz != 4)
16519                     printf (_("<corrupt length: %#x> "), datasz);
16520                   else
16521                     decode_x86_feature (type, byte_get (ptr, 4));
16522                   goto next;
16523
16524                 default:
16525                   break;
16526                 }
16527             }
16528         }
16529       else
16530         {
16531           switch (type)
16532             {
16533             case GNU_PROPERTY_STACK_SIZE:
16534               printf (_("stack size: "));
16535               if (datasz != size)
16536                 printf (_("<corrupt length: %#x> "), datasz);
16537               else
16538                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16539               goto next;
16540
16541             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16542               printf ("no copy on protected ");
16543               if (datasz)
16544                 printf (_("<corrupt length: %#x> "), datasz);
16545               goto next;
16546
16547             default:
16548               break;
16549             }
16550         }
16551
16552       if (type < GNU_PROPERTY_LOPROC)
16553         printf (_("<unknown type %#x data: "), type);
16554       else if (type < GNU_PROPERTY_LOUSER)
16555         printf (_("<procesor-specific type %#x data: "), type);
16556       else
16557         printf (_("<application-specific type %#x data: "), type);
16558       for (j = 0; j < datasz; ++j)
16559         printf ("%02x ", ptr[j] & 0xff);
16560       printf (">");
16561
16562 next:
16563       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16564       if (ptr == ptr_end)
16565         break;
16566       else
16567         {
16568           if (do_wide)
16569             printf (", ");
16570           else
16571             printf ("\n\t");
16572         }
16573
16574       if (ptr > (ptr_end - 8))
16575         {
16576           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16577           break;
16578         }
16579     }
16580
16581   printf ("\n");
16582 }
16583
16584 static bfd_boolean
16585 print_gnu_note (Elf_Internal_Note *pnote)
16586 {
16587   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16588   switch (pnote->type)
16589     {
16590     case NT_GNU_BUILD_ID:
16591       {
16592         unsigned long i;
16593
16594         printf (_("    Build ID: "));
16595         for (i = 0; i < pnote->descsz; ++i)
16596           printf ("%02x", pnote->descdata[i] & 0xff);
16597         printf ("\n");
16598       }
16599       break;
16600
16601     case NT_GNU_ABI_TAG:
16602       {
16603         unsigned long os, major, minor, subminor;
16604         const char *osname;
16605
16606         /* PR 17531: file: 030-599401-0.004.  */
16607         if (pnote->descsz < 16)
16608           {
16609             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16610             break;
16611           }
16612
16613         os = byte_get ((unsigned char *) pnote->descdata, 4);
16614         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16615         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16616         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16617
16618         switch (os)
16619           {
16620           case GNU_ABI_TAG_LINUX:
16621             osname = "Linux";
16622             break;
16623           case GNU_ABI_TAG_HURD:
16624             osname = "Hurd";
16625             break;
16626           case GNU_ABI_TAG_SOLARIS:
16627             osname = "Solaris";
16628             break;
16629           case GNU_ABI_TAG_FREEBSD:
16630             osname = "FreeBSD";
16631             break;
16632           case GNU_ABI_TAG_NETBSD:
16633             osname = "NetBSD";
16634             break;
16635           case GNU_ABI_TAG_SYLLABLE:
16636             osname = "Syllable";
16637             break;
16638           case GNU_ABI_TAG_NACL:
16639             osname = "NaCl";
16640             break;
16641           default:
16642             osname = "Unknown";
16643             break;
16644           }
16645
16646         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16647                 major, minor, subminor);
16648       }
16649       break;
16650
16651     case NT_GNU_GOLD_VERSION:
16652       {
16653         unsigned long i;
16654
16655         printf (_("    Version: "));
16656         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16657           printf ("%c", pnote->descdata[i]);
16658         printf ("\n");
16659       }
16660       break;
16661
16662     case NT_GNU_HWCAP:
16663       {
16664         unsigned long num_entries, mask;
16665
16666         /* Hardware capabilities information.  Word 0 is the number of entries.
16667            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16668            is a series of entries, where each entry is a single byte followed
16669            by a nul terminated string.  The byte gives the bit number to test
16670            if enabled in the bitmask.  */
16671         printf (_("      Hardware Capabilities: "));
16672         if (pnote->descsz < 8)
16673           {
16674             error (_("<corrupt GNU_HWCAP>\n"));
16675             return FALSE;
16676           }
16677         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16678         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16679         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16680         /* FIXME: Add code to display the entries... */
16681       }
16682       break;
16683
16684     case NT_GNU_PROPERTY_TYPE_0:
16685       print_gnu_property_note (pnote);
16686       break;
16687
16688     default:
16689       /* Handle unrecognised types.  An error message should have already been
16690          created by get_gnu_elf_note_type(), so all that we need to do is to
16691          display the data.  */
16692       {
16693         unsigned long i;
16694
16695         printf (_("    Description data: "));
16696         for (i = 0; i < pnote->descsz; ++i)
16697           printf ("%02x ", pnote->descdata[i] & 0xff);
16698         printf ("\n");
16699       }
16700       break;
16701     }
16702
16703   return TRUE;
16704 }
16705
16706 static const char *
16707 get_v850_elf_note_type (enum v850_notes n_type)
16708 {
16709   static char buff[64];
16710
16711   switch (n_type)
16712     {
16713     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16714     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16715     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16716     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16717     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16718     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16719     default:
16720       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16721       return buff;
16722     }
16723 }
16724
16725 static bfd_boolean
16726 print_v850_note (Elf_Internal_Note * pnote)
16727 {
16728   unsigned int val;
16729
16730   if (pnote->descsz != 4)
16731     return FALSE;
16732
16733   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16734
16735   if (val == 0)
16736     {
16737       printf (_("not set\n"));
16738       return TRUE;
16739     }
16740
16741   switch (pnote->type)
16742     {
16743     case V850_NOTE_ALIGNMENT:
16744       switch (val)
16745         {
16746         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16747         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16748         }
16749       break;
16750
16751     case V850_NOTE_DATA_SIZE:
16752       switch (val)
16753         {
16754         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16755         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16756         }
16757       break;
16758
16759     case V850_NOTE_FPU_INFO:
16760       switch (val)
16761         {
16762         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16763         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16764         }
16765       break;
16766
16767     case V850_NOTE_MMU_INFO:
16768     case V850_NOTE_CACHE_INFO:
16769     case V850_NOTE_SIMD_INFO:
16770       if (val == EF_RH850_SIMD)
16771         {
16772           printf (_("yes\n"));
16773           return TRUE;
16774         }
16775       break;
16776
16777     default:
16778       /* An 'unknown note type' message will already have been displayed.  */
16779       break;
16780     }
16781
16782   printf (_("unknown value: %x\n"), val);
16783   return FALSE;
16784 }
16785
16786 static bfd_boolean
16787 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16788 {
16789   unsigned int version;
16790
16791   switch (pnote->type)
16792     {
16793     case NT_NETBSD_IDENT:
16794       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16795       if ((version / 10000) % 100)
16796         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16797                 version, version / 100000000, (version / 1000000) % 100,
16798                 (version / 10000) % 100 > 26 ? "Z" : "",
16799                 'A' + (version / 10000) % 26);
16800       else
16801         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16802                 version, version / 100000000, (version / 1000000) % 100,
16803                 (version / 100) % 100);
16804       return TRUE;
16805
16806     case NT_NETBSD_MARCH:
16807       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16808               pnote->descdata);
16809       return TRUE;
16810
16811     default:
16812       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16813               pnote->type);
16814       return FALSE;
16815     }
16816 }
16817
16818 static const char *
16819 get_freebsd_elfcore_note_type (unsigned e_type)
16820 {
16821   switch (e_type)
16822     {
16823     case NT_FREEBSD_THRMISC:
16824       return _("NT_THRMISC (thrmisc structure)");
16825     case NT_FREEBSD_PROCSTAT_PROC:
16826       return _("NT_PROCSTAT_PROC (proc data)");
16827     case NT_FREEBSD_PROCSTAT_FILES:
16828       return _("NT_PROCSTAT_FILES (files data)");
16829     case NT_FREEBSD_PROCSTAT_VMMAP:
16830       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16831     case NT_FREEBSD_PROCSTAT_GROUPS:
16832       return _("NT_PROCSTAT_GROUPS (groups data)");
16833     case NT_FREEBSD_PROCSTAT_UMASK:
16834       return _("NT_PROCSTAT_UMASK (umask data)");
16835     case NT_FREEBSD_PROCSTAT_RLIMIT:
16836       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16837     case NT_FREEBSD_PROCSTAT_OSREL:
16838       return _("NT_PROCSTAT_OSREL (osreldate data)");
16839     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16840       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16841     case NT_FREEBSD_PROCSTAT_AUXV:
16842       return _("NT_PROCSTAT_AUXV (auxv data)");
16843     case NT_FREEBSD_PTLWPINFO:
16844       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16845     }
16846   return get_note_type (e_type);
16847 }
16848
16849 static const char *
16850 get_netbsd_elfcore_note_type (unsigned e_type)
16851 {
16852   static char buff[64];
16853
16854   if (e_type == NT_NETBSDCORE_PROCINFO)
16855     {
16856       /* NetBSD core "procinfo" structure.  */
16857       return _("NetBSD procinfo structure");
16858     }
16859
16860   /* As of Jan 2002 there are no other machine-independent notes
16861      defined for NetBSD core files.  If the note type is less
16862      than the start of the machine-dependent note types, we don't
16863      understand it.  */
16864
16865   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16866     {
16867       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16868       return buff;
16869     }
16870
16871   switch (elf_header.e_machine)
16872     {
16873     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16874        and PT_GETFPREGS == mach+2.  */
16875
16876     case EM_OLD_ALPHA:
16877     case EM_ALPHA:
16878     case EM_SPARC:
16879     case EM_SPARC32PLUS:
16880     case EM_SPARCV9:
16881       switch (e_type)
16882         {
16883         case NT_NETBSDCORE_FIRSTMACH + 0:
16884           return _("PT_GETREGS (reg structure)");
16885         case NT_NETBSDCORE_FIRSTMACH + 2:
16886           return _("PT_GETFPREGS (fpreg structure)");
16887         default:
16888           break;
16889         }
16890       break;
16891
16892     /* On all other arch's, PT_GETREGS == mach+1 and
16893        PT_GETFPREGS == mach+3.  */
16894     default:
16895       switch (e_type)
16896         {
16897         case NT_NETBSDCORE_FIRSTMACH + 1:
16898           return _("PT_GETREGS (reg structure)");
16899         case NT_NETBSDCORE_FIRSTMACH + 3:
16900           return _("PT_GETFPREGS (fpreg structure)");
16901         default:
16902           break;
16903         }
16904     }
16905
16906   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16907             e_type - NT_NETBSDCORE_FIRSTMACH);
16908   return buff;
16909 }
16910
16911 static const char *
16912 get_stapsdt_note_type (unsigned e_type)
16913 {
16914   static char buff[64];
16915
16916   switch (e_type)
16917     {
16918     case NT_STAPSDT:
16919       return _("NT_STAPSDT (SystemTap probe descriptors)");
16920
16921     default:
16922       break;
16923     }
16924
16925   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16926   return buff;
16927 }
16928
16929 static bfd_boolean
16930 print_stapsdt_note (Elf_Internal_Note *pnote)
16931 {
16932   int addr_size = is_32bit_elf ? 4 : 8;
16933   char *data = pnote->descdata;
16934   char *data_end = pnote->descdata + pnote->descsz;
16935   bfd_vma pc, base_addr, semaphore;
16936   char *provider, *probe, *arg_fmt;
16937
16938   pc = byte_get ((unsigned char *) data, addr_size);
16939   data += addr_size;
16940   base_addr = byte_get ((unsigned char *) data, addr_size);
16941   data += addr_size;
16942   semaphore = byte_get ((unsigned char *) data, addr_size);
16943   data += addr_size;
16944
16945   provider = data;
16946   data += strlen (data) + 1;
16947   probe = data;
16948   data += strlen (data) + 1;
16949   arg_fmt = data;
16950   data += strlen (data) + 1;
16951
16952   printf (_("    Provider: %s\n"), provider);
16953   printf (_("    Name: %s\n"), probe);
16954   printf (_("    Location: "));
16955   print_vma (pc, FULL_HEX);
16956   printf (_(", Base: "));
16957   print_vma (base_addr, FULL_HEX);
16958   printf (_(", Semaphore: "));
16959   print_vma (semaphore, FULL_HEX);
16960   printf ("\n");
16961   printf (_("    Arguments: %s\n"), arg_fmt);
16962
16963   return data == data_end;
16964 }
16965
16966 static const char *
16967 get_ia64_vms_note_type (unsigned e_type)
16968 {
16969   static char buff[64];
16970
16971   switch (e_type)
16972     {
16973     case NT_VMS_MHD:
16974       return _("NT_VMS_MHD (module header)");
16975     case NT_VMS_LNM:
16976       return _("NT_VMS_LNM (language name)");
16977     case NT_VMS_SRC:
16978       return _("NT_VMS_SRC (source files)");
16979     case NT_VMS_TITLE:
16980       return "NT_VMS_TITLE";
16981     case NT_VMS_EIDC:
16982       return _("NT_VMS_EIDC (consistency check)");
16983     case NT_VMS_FPMODE:
16984       return _("NT_VMS_FPMODE (FP mode)");
16985     case NT_VMS_LINKTIME:
16986       return "NT_VMS_LINKTIME";
16987     case NT_VMS_IMGNAM:
16988       return _("NT_VMS_IMGNAM (image name)");
16989     case NT_VMS_IMGID:
16990       return _("NT_VMS_IMGID (image id)");
16991     case NT_VMS_LINKID:
16992       return _("NT_VMS_LINKID (link id)");
16993     case NT_VMS_IMGBID:
16994       return _("NT_VMS_IMGBID (build id)");
16995     case NT_VMS_GSTNAM:
16996       return _("NT_VMS_GSTNAM (sym table name)");
16997     case NT_VMS_ORIG_DYN:
16998       return "NT_VMS_ORIG_DYN";
16999     case NT_VMS_PATCHTIME:
17000       return "NT_VMS_PATCHTIME";
17001     default:
17002       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17003       return buff;
17004     }
17005 }
17006
17007 static bfd_boolean
17008 print_ia64_vms_note (Elf_Internal_Note * pnote)
17009 {
17010   switch (pnote->type)
17011     {
17012     case NT_VMS_MHD:
17013       if (pnote->descsz > 36)
17014         {
17015           size_t l = strlen (pnote->descdata + 34);
17016           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17017           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17018           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17019           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17020         }
17021       else
17022         printf (_("    Invalid size\n"));
17023       break;
17024     case NT_VMS_LNM:
17025       printf (_("   Language: %s\n"), pnote->descdata);
17026       break;
17027 #ifdef BFD64
17028     case NT_VMS_FPMODE:
17029       printf (_("   Floating Point mode: "));
17030       printf ("0x%016" BFD_VMA_FMT "x\n",
17031               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17032       break;
17033     case NT_VMS_LINKTIME:
17034       printf (_("   Link time: "));
17035       print_vms_time
17036         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17037       printf ("\n");
17038       break;
17039     case NT_VMS_PATCHTIME:
17040       printf (_("   Patch time: "));
17041       print_vms_time
17042         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17043       printf ("\n");
17044       break;
17045     case NT_VMS_ORIG_DYN:
17046       printf (_("   Major id: %u,  minor id: %u\n"),
17047               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17048               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17049       printf (_("   Last modified  : "));
17050       print_vms_time
17051         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17052       printf (_("\n   Link flags  : "));
17053       printf ("0x%016" BFD_VMA_FMT "x\n",
17054               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17055       printf (_("   Header flags: 0x%08x\n"),
17056               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17057       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17058       break;
17059 #endif
17060     case NT_VMS_IMGNAM:
17061       printf (_("    Image name: %s\n"), pnote->descdata);
17062       break;
17063     case NT_VMS_GSTNAM:
17064       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17065       break;
17066     case NT_VMS_IMGID:
17067       printf (_("    Image id: %s\n"), pnote->descdata);
17068       break;
17069     case NT_VMS_LINKID:
17070       printf (_("    Linker id: %s\n"), pnote->descdata);
17071       break;
17072     default:
17073       return FALSE;
17074     }
17075   return TRUE;
17076 }
17077
17078 /* Print the name of the symbol associated with a build attribute
17079    that is attached to address OFFSET.  */
17080
17081 static bfd_boolean
17082 print_symbol_for_build_attribute (FILE *         file,
17083                                   unsigned long  offset,
17084                                   bfd_boolean    is_open_attr)
17085 {
17086   static FILE *             saved_file = NULL;
17087   static char *             strtab;
17088   static unsigned long      strtablen;
17089   static Elf_Internal_Sym * symtab;
17090   static unsigned long      nsyms;
17091   Elf_Internal_Sym *        saved_sym = NULL;
17092   Elf_Internal_Sym *        sym;
17093
17094   if (section_headers != NULL
17095       && (saved_file == NULL || file != saved_file))
17096     {
17097       Elf_Internal_Shdr * symsec;
17098
17099       /* Load the symbol and string sections.  */
17100       for (symsec = section_headers;
17101            symsec < section_headers + elf_header.e_shnum;
17102            symsec ++)
17103         {
17104           if (symsec->sh_type == SHT_SYMTAB)
17105             {
17106               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17107
17108               if (symsec->sh_link < elf_header.e_shnum)
17109                 {
17110                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17111
17112                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17113                                               1, strtab_sec->sh_size,
17114                                               _("string table"));
17115                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17116                 }
17117             }
17118         }
17119       saved_file = file;
17120     }
17121
17122   if (symtab == NULL || strtab == NULL)
17123     {
17124       printf ("\n");
17125       return FALSE;
17126     }
17127
17128   /* Find a symbol whose value matches offset.  */
17129   for (sym = symtab; sym < symtab + nsyms; sym ++)
17130     if (sym->st_value == offset)
17131       {
17132         if (sym->st_name >= strtablen)
17133           /* Huh ?  This should not happen.  */
17134           continue;
17135
17136         if (strtab[sym->st_name] == 0)
17137           continue;
17138
17139         if (is_open_attr)
17140           {
17141             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17142                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17143                FUNC symbols entirely.  */
17144             switch (ELF_ST_TYPE (sym->st_info))
17145               {
17146               case STT_FILE:
17147                 saved_sym = sym;
17148                 /* We can stop searching now.  */
17149                 sym = symtab + nsyms;
17150                 continue;
17151
17152               case STT_OBJECT:
17153                 saved_sym = sym;
17154                 continue;
17155
17156               case STT_FUNC:
17157                 /* Ignore function symbols.  */
17158                 continue;
17159
17160               default:
17161                 break;
17162               }
17163
17164             switch (ELF_ST_BIND (sym->st_info))
17165               {
17166               case STB_GLOBAL:
17167                 if (saved_sym == NULL
17168                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17169                   saved_sym = sym;
17170                 break;
17171
17172               case STB_LOCAL:
17173                 if (saved_sym == NULL)
17174                   saved_sym = sym;
17175                 break;
17176
17177               default:
17178                 break;
17179               }
17180           }
17181         else
17182           {
17183             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17184               continue;
17185
17186             saved_sym = sym;
17187             break;
17188           }
17189       }
17190
17191   printf (" (%s: %s)\n",
17192           is_open_attr ? _("file") : _("func"),
17193           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17194   return TRUE;
17195 }
17196
17197 static bfd_boolean
17198 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17199                                        FILE *              file)
17200 {
17201   static unsigned long global_offset = 0;
17202   unsigned long        offset;
17203   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17204   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17205
17206   if (pnote->descsz == 0)
17207     {
17208       if (is_open_attr)
17209         {
17210           printf (_("    Applies from offset %#lx\n"), global_offset);
17211           return TRUE;
17212         }
17213       else
17214         {
17215           printf (_("    Applies to func at %#lx"), global_offset);
17216           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17217         }
17218     }
17219
17220   if (pnote->descsz != desc_size)
17221     {
17222       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17223       printf (_("    <invalid descsz>"));
17224       return FALSE;
17225     }
17226
17227   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17228
17229   if (is_open_attr)
17230     {
17231       printf (_("    Applies from offset %#lx"), offset);
17232       global_offset = offset;
17233     }
17234   else
17235     {
17236       printf (_("    Applies to func at %#lx"), offset);
17237     }
17238
17239   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17240 }
17241
17242 static bfd_boolean
17243 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17244 {
17245   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17246   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17247   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17248   char         name_type;
17249   char         name_attribute;
17250   const char * expected_types;
17251   const char * name = pnote->namedata;
17252   const char * text;
17253   signed int   left;
17254
17255   if (name == NULL || pnote->namesz < 2)
17256     {
17257       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17258       print_symbol (-20, _("  <corrupt name>"));
17259       return FALSE;
17260     }
17261
17262   left = 20;
17263
17264   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17265   if (name[0] == 'G' && name[1] == 'A')
17266     {
17267       printf ("GA");
17268       name += 2;
17269       left -= 2;
17270     }
17271
17272   switch ((name_type = * name))
17273     {
17274     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17275     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17276     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17277     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17278       printf ("%c", * name);
17279       left --;
17280       break;
17281     default:
17282       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17283       print_symbol (-20, _("<unknown name type>"));
17284       return FALSE;
17285     }
17286
17287   ++ name;
17288   text = NULL;
17289
17290   switch ((name_attribute = * name))
17291     {
17292     case GNU_BUILD_ATTRIBUTE_VERSION:
17293       text = _("<version>");
17294       expected_types = string_expected;
17295       ++ name;
17296       break;
17297     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17298       text = _("<stack prot>");
17299       expected_types = "!+*";
17300       ++ name;
17301       break;
17302     case GNU_BUILD_ATTRIBUTE_RELRO:
17303       text = _("<relro>");
17304       expected_types = bool_expected;
17305       ++ name;
17306       break;
17307     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17308       text = _("<stack size>");
17309       expected_types = number_expected;
17310       ++ name;
17311       break;
17312     case GNU_BUILD_ATTRIBUTE_TOOL:
17313       text = _("<tool>");
17314       expected_types = string_expected;
17315       ++ name;
17316       break;
17317     case GNU_BUILD_ATTRIBUTE_ABI:
17318       text = _("<ABI>");
17319       expected_types = "$*";
17320       ++ name;
17321       break;
17322     case GNU_BUILD_ATTRIBUTE_PIC:
17323       text = _("<PIC>");
17324       expected_types = number_expected;
17325       ++ name;
17326       break;
17327     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17328       text = _("<short enum>");
17329       expected_types = bool_expected;
17330       ++ name;
17331       break;
17332     default:
17333       if (ISPRINT (* name))
17334         {
17335           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17336
17337           if (len > left && ! do_wide)
17338             len = left;
17339           printf ("%.*s:", len, name);
17340           left -= len;
17341           name += len;
17342         }
17343       else
17344         {
17345           static char tmpbuf [128];
17346
17347           error (_("unrecognised byte in name field: %d\n"), * name);
17348           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17349           text = tmpbuf;
17350           name ++;
17351         }
17352       expected_types = "*$!+";
17353       break;
17354     }
17355
17356   if (text)
17357     left -= printf ("%s", text);
17358
17359   if (strchr (expected_types, name_type) == NULL)
17360     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17361
17362   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17363     {
17364       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17365              (unsigned long) pnote->namesz,
17366              (long) (name - pnote->namedata));
17367       return FALSE;
17368     }
17369
17370   if (left < 1 && ! do_wide)
17371     return TRUE;
17372
17373   switch (name_type)
17374     {
17375     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17376       {
17377         unsigned int        bytes;
17378         unsigned long long  val = 0;
17379         unsigned int        shift = 0;
17380         char *              decoded = NULL;
17381
17382         bytes = pnote->namesz - (name - pnote->namedata);
17383         if (bytes > 0)
17384           /* The -1 is because the name field is always 0 terminated, and we
17385              want to be able to ensure that the shift in the while loop below
17386              will not overflow.  */
17387           -- bytes;
17388
17389         if (bytes > sizeof (val))
17390           {
17391             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17392                      pnote->namesz, name, pnote->namedata);
17393             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17394                    bytes);
17395             bytes = sizeof (val);
17396           }
17397         /* We do not bother to warn if bytes == 0 as this can
17398            happen with some early versions of the gcc plugin.  */
17399
17400         while (bytes --)
17401           {
17402             unsigned long byte = (* name ++) & 0xff;
17403
17404             val |= byte << shift;
17405             shift += 8;
17406           }
17407
17408         switch (name_attribute)
17409           {
17410           case GNU_BUILD_ATTRIBUTE_PIC:
17411             switch (val)
17412               {
17413               case 0: decoded = "static"; break;
17414               case 1: decoded = "pic"; break;
17415               case 2: decoded = "PIC"; break;
17416               case 3: decoded = "pie"; break;
17417               case 4: decoded = "PIE"; break;
17418               default: break;
17419               }
17420             break;
17421           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17422             switch (val)
17423               {
17424                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17425               case 0: decoded = "off"; break;
17426               case 1: decoded = "on"; break;
17427               case 2: decoded = "all"; break;
17428               case 3: decoded = "strong"; break;
17429               case 4: decoded = "explicit"; break;
17430               default: break;
17431               }
17432             break;
17433           default:
17434             break;
17435           }
17436
17437         if (decoded != NULL)
17438           {
17439             print_symbol (-left, decoded);
17440             left = 0;
17441           }
17442         else if (val == 0)
17443           {
17444             printf ("0x0");
17445             left -= 3;
17446           }
17447         else
17448           {
17449             if (do_wide)
17450               left -= printf ("0x%llx", val);
17451             else
17452               left -= printf ("0x%-.*llx", left, val);
17453           }
17454       }
17455       break;
17456     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17457       left -= print_symbol (- left, name);
17458       break;
17459     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17460       left -= print_symbol (- left, "true");
17461       break;
17462     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17463       left -= print_symbol (- left, "false");
17464       break;
17465     }
17466
17467   if (do_wide && left > 0)
17468     printf ("%-*s", left, " ");
17469
17470   return TRUE;
17471 }
17472
17473 /* Note that by the ELF standard, the name field is already null byte
17474    terminated, and namesz includes the terminating null byte.
17475    I.E. the value of namesz for the name "FSF" is 4.
17476
17477    If the value of namesz is zero, there is no name present.  */
17478
17479 static bfd_boolean
17480 process_note (Elf_Internal_Note *  pnote,
17481               FILE *               file)
17482 {
17483   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17484   const char * nt;
17485
17486   if (pnote->namesz == 0)
17487     /* If there is no note name, then use the default set of
17488        note type strings.  */
17489     nt = get_note_type (pnote->type);
17490
17491   else if (const_strneq (pnote->namedata, "GNU"))
17492     /* GNU-specific object file notes.  */
17493     nt = get_gnu_elf_note_type (pnote->type);
17494
17495   else if (const_strneq (pnote->namedata, "FreeBSD"))
17496     /* FreeBSD-specific core file notes.  */
17497     nt = get_freebsd_elfcore_note_type (pnote->type);
17498
17499   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17500     /* NetBSD-specific core file notes.  */
17501     nt = get_netbsd_elfcore_note_type (pnote->type);
17502
17503   else if (const_strneq (pnote->namedata, "NetBSD"))
17504     /* NetBSD-specific core file notes.  */
17505     return process_netbsd_elf_note (pnote);
17506
17507   else if (strneq (pnote->namedata, "SPU/", 4))
17508     {
17509       /* SPU-specific core file notes.  */
17510       nt = pnote->namedata + 4;
17511       name = "SPU";
17512     }
17513
17514   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17515     /* VMS/ia64-specific file notes.  */
17516     nt = get_ia64_vms_note_type (pnote->type);
17517
17518   else if (const_strneq (pnote->namedata, "stapsdt"))
17519     nt = get_stapsdt_note_type (pnote->type);
17520
17521   else
17522     /* Don't recognize this note name; just use the default set of
17523        note type strings.  */
17524     nt = get_note_type (pnote->type);
17525
17526   printf ("  ");
17527
17528   if (((const_strneq (pnote->namedata, "GA")
17529         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17530        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17531       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17532           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17533     print_gnu_build_attribute_name (pnote);
17534   else
17535     print_symbol (-20, name);
17536
17537   if (do_wide)
17538     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17539   else
17540     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17541
17542   if (const_strneq (pnote->namedata, "IPF/VMS"))
17543     return print_ia64_vms_note (pnote);
17544   else if (const_strneq (pnote->namedata, "GNU"))
17545     return print_gnu_note (pnote);
17546   else if (const_strneq (pnote->namedata, "stapsdt"))
17547     return print_stapsdt_note (pnote);
17548   else if (const_strneq (pnote->namedata, "CORE"))
17549     return print_core_note (pnote);
17550   else if (((const_strneq (pnote->namedata, "GA")
17551              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17552             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17553            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17554                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17555     return print_gnu_build_attribute_description (pnote, file);
17556
17557   if (pnote->descsz)
17558     {
17559       unsigned long i;
17560
17561       printf (_("   description data: "));
17562       for (i = 0; i < pnote->descsz; i++)
17563         printf ("%02x ", pnote->descdata[i]);
17564       if (!do_wide)
17565         printf ("\n");
17566     }
17567
17568   if (do_wide)
17569     printf ("\n");
17570
17571   return TRUE;
17572 }
17573
17574 static bfd_boolean
17575 process_notes_at (FILE *              file,
17576                   Elf_Internal_Shdr * section,
17577                   bfd_vma             offset,
17578                   bfd_vma             length)
17579 {
17580   Elf_External_Note * pnotes;
17581   Elf_External_Note * external;
17582   char * end;
17583   bfd_boolean res = TRUE;
17584
17585   if (length <= 0)
17586     return FALSE;
17587
17588   if (section)
17589     {
17590       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17591       if (pnotes)
17592         {
17593           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17594             return FALSE;
17595         }
17596     }
17597   else
17598     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17599                                              _("notes"));
17600   if (pnotes == NULL)
17601     return FALSE;
17602
17603   external = pnotes;
17604
17605   if (section)
17606     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17607   else
17608     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17609             (unsigned long) offset, (unsigned long) length);
17610
17611   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17612
17613   end = (char *) pnotes + length;
17614   while ((char *) external < end)
17615     {
17616       Elf_Internal_Note inote;
17617       size_t min_notesz;
17618       char *next;
17619       char * temp = NULL;
17620       size_t data_remaining = end - (char *) external;
17621
17622       if (!is_ia64_vms ())
17623         {
17624           /* PR binutils/15191
17625              Make sure that there is enough data to read.  */
17626           min_notesz = offsetof (Elf_External_Note, name);
17627           if (data_remaining < min_notesz)
17628             {
17629               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17630                     (int) data_remaining);
17631               break;
17632             }
17633           inote.type     = BYTE_GET (external->type);
17634           inote.namesz   = BYTE_GET (external->namesz);
17635           inote.namedata = external->name;
17636           inote.descsz   = BYTE_GET (external->descsz);
17637           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17638           /* PR 17531: file: 3443835e.  */
17639           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17640             {
17641               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17642                     inote.namesz, (long)(end - inote.namedata));
17643               inote.descdata = inote.namedata;
17644               inote.namesz   = 0;
17645             }
17646
17647           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17648           next = inote.descdata + align_power (inote.descsz, 2);
17649         }
17650       else
17651         {
17652           Elf64_External_VMS_Note *vms_external;
17653
17654           /* PR binutils/15191
17655              Make sure that there is enough data to read.  */
17656           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17657           if (data_remaining < min_notesz)
17658             {
17659               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17660                     (int) data_remaining);
17661               break;
17662             }
17663
17664           vms_external = (Elf64_External_VMS_Note *) external;
17665           inote.type     = BYTE_GET (vms_external->type);
17666           inote.namesz   = BYTE_GET (vms_external->namesz);
17667           inote.namedata = vms_external->name;
17668           inote.descsz   = BYTE_GET (vms_external->descsz);
17669           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17670           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17671           next = inote.descdata + align_power (inote.descsz, 3);
17672         }
17673
17674       if (inote.descdata < (char *) external + min_notesz
17675           || next < (char *) external + min_notesz
17676           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17677           || inote.namedata + inote.namesz < inote.namedata
17678           || inote.descdata + inote.descsz < inote.descdata
17679           || data_remaining < (size_t)(next - (char *) external))
17680         {
17681           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17682                 (unsigned long) ((char *) external - (char *) pnotes));
17683           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17684                 inote.type, inote.namesz, inote.descsz);
17685           break;
17686         }
17687
17688       external = (Elf_External_Note *) next;
17689
17690       /* Verify that name is null terminated.  It appears that at least
17691          one version of Linux (RedHat 6.0) generates corefiles that don't
17692          comply with the ELF spec by failing to include the null byte in
17693          namesz.  */
17694       if (inote.namedata[inote.namesz - 1] != '\0')
17695         {
17696           temp = (char *) malloc (inote.namesz + 1);
17697           if (temp == NULL)
17698             {
17699               error (_("Out of memory allocating space for inote name\n"));
17700               res = FALSE;
17701               break;
17702             }
17703
17704           memcpy (temp, inote.namedata, inote.namesz);
17705           temp[inote.namesz] = 0;
17706
17707           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17708           inote.namedata = temp;
17709         }
17710
17711       if (! process_note (& inote, file))
17712         res = FALSE;
17713
17714       if (temp != NULL)
17715         {
17716           free (temp);
17717           temp = NULL;
17718         }
17719     }
17720
17721   free (pnotes);
17722
17723   return res;
17724 }
17725
17726 static bfd_boolean
17727 process_corefile_note_segments (FILE * file)
17728 {
17729   Elf_Internal_Phdr * segment;
17730   unsigned int i;
17731   bfd_boolean res = TRUE;
17732
17733   if (! get_program_headers (file))
17734     return TRUE;
17735
17736   for (i = 0, segment = program_headers;
17737        i < elf_header.e_phnum;
17738        i++, segment++)
17739     {
17740       if (segment->p_type == PT_NOTE)
17741         if (! process_notes_at (file, NULL,
17742                                 (bfd_vma) segment->p_offset,
17743                                 (bfd_vma) segment->p_filesz))
17744           res = FALSE;
17745     }
17746
17747   return res;
17748 }
17749
17750 static bfd_boolean
17751 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17752 {
17753   Elf_External_Note * pnotes;
17754   Elf_External_Note * external;
17755   char * end;
17756   bfd_boolean res = TRUE;
17757
17758   if (length <= 0)
17759     return FALSE;
17760
17761   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17762                                            _("v850 notes"));
17763   if (pnotes == NULL)
17764     return FALSE;
17765
17766   external = pnotes;
17767   end = (char*) pnotes + length;
17768
17769   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17770           (unsigned long) offset, (unsigned long) length);
17771
17772   while ((char *) external + sizeof (Elf_External_Note) < end)
17773     {
17774       Elf_External_Note * next;
17775       Elf_Internal_Note inote;
17776
17777       inote.type     = BYTE_GET (external->type);
17778       inote.namesz   = BYTE_GET (external->namesz);
17779       inote.namedata = external->name;
17780       inote.descsz   = BYTE_GET (external->descsz);
17781       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17782       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17783
17784       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17785         {
17786           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17787           inote.descdata = inote.namedata;
17788           inote.namesz   = 0;
17789         }
17790
17791       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17792
17793       if (   ((char *) next > end)
17794           || ((char *) next <  (char *) pnotes))
17795         {
17796           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17797                 (unsigned long) ((char *) external - (char *) pnotes));
17798           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17799                 inote.type, inote.namesz, inote.descsz);
17800           break;
17801         }
17802
17803       external = next;
17804
17805       /* Prevent out-of-bounds indexing.  */
17806       if (   inote.namedata + inote.namesz > end
17807           || inote.namedata + inote.namesz < inote.namedata)
17808         {
17809           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17810                 (unsigned long) ((char *) external - (char *) pnotes));
17811           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17812                 inote.type, inote.namesz, inote.descsz);
17813           break;
17814         }
17815
17816       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17817
17818       if (! print_v850_note (& inote))
17819         {
17820           res = FALSE;
17821           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17822                   inote.namesz, inote.descsz);
17823         }
17824     }
17825
17826   free (pnotes);
17827
17828   return res;
17829 }
17830
17831 static bfd_boolean
17832 process_note_sections (FILE * file)
17833 {
17834   Elf_Internal_Shdr * section;
17835   unsigned long i;
17836   unsigned int n = 0;
17837   bfd_boolean res = TRUE;
17838
17839   for (i = 0, section = section_headers;
17840        i < elf_header.e_shnum && section != NULL;
17841        i++, section++)
17842     {
17843       if (section->sh_type == SHT_NOTE)
17844         {
17845           if (! process_notes_at (file, section,
17846                                   (bfd_vma) section->sh_offset,
17847                                   (bfd_vma) section->sh_size))
17848             res = FALSE;
17849           n++;
17850         }
17851
17852       if ((   elf_header.e_machine == EM_V800
17853            || elf_header.e_machine == EM_V850
17854            || elf_header.e_machine == EM_CYGNUS_V850)
17855           && section->sh_type == SHT_RENESAS_INFO)
17856         {
17857           if (! process_v850_notes (file,
17858                                     (bfd_vma) section->sh_offset,
17859                                     (bfd_vma) section->sh_size))
17860             res = FALSE;
17861           n++;
17862         }
17863     }
17864
17865   if (n == 0)
17866     /* Try processing NOTE segments instead.  */
17867     return process_corefile_note_segments (file);
17868
17869   return res;
17870 }
17871
17872 static bfd_boolean
17873 process_notes (FILE * file)
17874 {
17875   /* If we have not been asked to display the notes then do nothing.  */
17876   if (! do_notes)
17877     return TRUE;
17878
17879   if (elf_header.e_type != ET_CORE)
17880     return process_note_sections (file);
17881
17882   /* No program headers means no NOTE segment.  */
17883   if (elf_header.e_phnum > 0)
17884     return process_corefile_note_segments (file);
17885
17886   printf (_("No note segments present in the core file.\n"));
17887   return TRUE;
17888 }
17889
17890 static unsigned char *
17891 display_public_gnu_attributes (unsigned char * start,
17892                                const unsigned char * const end)
17893 {
17894   printf (_("  Unknown GNU attribute: %s\n"), start);
17895
17896   start += strnlen ((char *) start, end - start);
17897   display_raw_attribute (start, end);
17898
17899   return (unsigned char *) end;
17900 }
17901
17902 static unsigned char *
17903 display_generic_attribute (unsigned char * start,
17904                            unsigned int tag,
17905                            const unsigned char * const end)
17906 {
17907   if (tag == 0)
17908     return (unsigned char *) end;
17909
17910   return display_tag_value (tag, start, end);
17911 }
17912
17913 static bfd_boolean
17914 process_arch_specific (FILE * file)
17915 {
17916   if (! do_arch)
17917     return TRUE;
17918
17919   switch (elf_header.e_machine)
17920     {
17921     case EM_ARC:
17922     case EM_ARC_COMPACT:
17923     case EM_ARC_COMPACT2:
17924       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17925                                  display_arc_attribute,
17926                                  display_generic_attribute);
17927     case EM_ARM:
17928       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17929                                  display_arm_attribute,
17930                                  display_generic_attribute);
17931
17932     case EM_MIPS:
17933     case EM_MIPS_RS3_LE:
17934       return process_mips_specific (file);
17935
17936     case EM_MSP430:
17937      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17938                                  display_msp430x_attribute,
17939                                  display_generic_attribute);
17940
17941     case EM_NDS32:
17942       return process_nds32_specific (file);
17943
17944     case EM_PPC:
17945     case EM_PPC64:
17946       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17947                                  display_power_gnu_attribute);
17948
17949     case EM_S390:
17950     case EM_S390_OLD:
17951       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17952                                  display_s390_gnu_attribute);
17953
17954     case EM_SPARC:
17955     case EM_SPARC32PLUS:
17956     case EM_SPARCV9:
17957       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17958                                  display_sparc_gnu_attribute);
17959
17960     case EM_TI_C6000:
17961       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17962                                  display_tic6x_attribute,
17963                                  display_generic_attribute);
17964
17965     default:
17966       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17967                                  display_public_gnu_attributes,
17968                                  display_generic_attribute);
17969     }
17970 }
17971
17972 static bfd_boolean
17973 get_file_header (FILE * file)
17974 {
17975   /* Read in the identity array.  */
17976   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17977     return FALSE;
17978
17979   /* Determine how to read the rest of the header.  */
17980   switch (elf_header.e_ident[EI_DATA])
17981     {
17982     default:
17983     case ELFDATANONE:
17984     case ELFDATA2LSB:
17985       byte_get = byte_get_little_endian;
17986       byte_put = byte_put_little_endian;
17987       break;
17988     case ELFDATA2MSB:
17989       byte_get = byte_get_big_endian;
17990       byte_put = byte_put_big_endian;
17991       break;
17992     }
17993
17994   /* For now we only support 32 bit and 64 bit ELF files.  */
17995   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17996
17997   /* Read in the rest of the header.  */
17998   if (is_32bit_elf)
17999     {
18000       Elf32_External_Ehdr ehdr32;
18001
18002       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
18003         return FALSE;
18004
18005       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
18006       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18007       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
18008       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18009       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18010       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18011       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18012       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18013       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18014       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18015       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18016       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18017       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18018     }
18019   else
18020     {
18021       Elf64_External_Ehdr ehdr64;
18022
18023       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18024          we will not be able to cope with the 64bit data found in
18025          64 ELF files.  Detect this now and abort before we start
18026          overwriting things.  */
18027       if (sizeof (bfd_vma) < 8)
18028         {
18029           error (_("This instance of readelf has been built without support for a\n\
18030 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18031           return FALSE;
18032         }
18033
18034       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18035         return FALSE;
18036
18037       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
18038       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18039       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
18040       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18041       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18042       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18043       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18044       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18045       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18046       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18047       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18048       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18049       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18050     }
18051
18052   if (elf_header.e_shoff)
18053     {
18054       /* There may be some extensions in the first section header.  Don't
18055          bomb if we can't read it.  */
18056       if (is_32bit_elf)
18057         get_32bit_section_headers (file, TRUE);
18058       else
18059         get_64bit_section_headers (file, TRUE);
18060     }
18061
18062   return TRUE;
18063 }
18064
18065 /* Process one ELF object file according to the command line options.
18066    This file may actually be stored in an archive.  The file is
18067    positioned at the start of the ELF object.  Returns TRUE if no
18068    problems were encountered, FALSE otherwise.  */
18069
18070 static bfd_boolean
18071 process_object (char * file_name, FILE * file)
18072 {
18073   unsigned int i;
18074   bfd_boolean res = TRUE;
18075
18076   if (! get_file_header (file))
18077     {
18078       error (_("%s: Failed to read file header\n"), file_name);
18079       return FALSE;
18080     }
18081
18082   /* Initialise per file variables.  */
18083   for (i = ARRAY_SIZE (version_info); i--;)
18084     version_info[i] = 0;
18085
18086   for (i = ARRAY_SIZE (dynamic_info); i--;)
18087     dynamic_info[i] = 0;
18088   dynamic_info_DT_GNU_HASH = 0;
18089
18090   /* Process the file.  */
18091   if (show_name)
18092     printf (_("\nFile: %s\n"), file_name);
18093
18094   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18095      Note we do this even if cmdline_dump_sects is empty because we
18096      must make sure that the dump_sets array is zeroed out before each
18097      object file is processed.  */
18098   if (num_dump_sects > num_cmdline_dump_sects)
18099     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18100
18101   if (num_cmdline_dump_sects > 0)
18102     {
18103       if (num_dump_sects == 0)
18104         /* A sneaky way of allocating the dump_sects array.  */
18105         request_dump_bynumber (num_cmdline_dump_sects, 0);
18106
18107       assert (num_dump_sects >= num_cmdline_dump_sects);
18108       memcpy (dump_sects, cmdline_dump_sects,
18109               num_cmdline_dump_sects * sizeof (* dump_sects));
18110     }
18111
18112   if (! process_file_header ())
18113     return FALSE;
18114
18115   if (! process_section_headers (file))
18116     {
18117       /* Without loaded section headers we cannot process lots of things.  */
18118       do_unwind = do_version = do_dump = do_arch = FALSE;
18119
18120       if (! do_using_dynamic)
18121         do_syms = do_dyn_syms = do_reloc = FALSE;
18122     }
18123
18124   if (! process_section_groups (file))
18125     /* Without loaded section groups we cannot process unwind.  */
18126     do_unwind = FALSE;
18127
18128   if (process_program_headers (file))
18129     process_dynamic_section (file);
18130   else
18131     res = FALSE;
18132
18133   if (! process_relocs (file))
18134     res = FALSE;
18135
18136   if (! process_unwind (file))
18137     res = FALSE;
18138
18139   if (! process_symbol_table (file))
18140     res = FALSE;
18141
18142   if (! process_syminfo (file))
18143     res = FALSE;
18144
18145   if (! process_version_sections (file))
18146     res = FALSE;
18147
18148   if (! process_section_contents (file))
18149     res = FALSE;
18150
18151   if (! process_notes (file))
18152     res = FALSE;
18153
18154   if (! process_gnu_liblist (file))
18155     res = FALSE;
18156
18157   if (! process_arch_specific (file))
18158     res = FALSE;
18159
18160   if (program_headers)
18161     {
18162       free (program_headers);
18163       program_headers = NULL;
18164     }
18165
18166   if (section_headers)
18167     {
18168       free (section_headers);
18169       section_headers = NULL;
18170     }
18171
18172   if (string_table)
18173     {
18174       free (string_table);
18175       string_table = NULL;
18176       string_table_length = 0;
18177     }
18178
18179   if (dynamic_strings)
18180     {
18181       free (dynamic_strings);
18182       dynamic_strings = NULL;
18183       dynamic_strings_length = 0;
18184     }
18185
18186   if (dynamic_symbols)
18187     {
18188       free (dynamic_symbols);
18189       dynamic_symbols = NULL;
18190       num_dynamic_syms = 0;
18191     }
18192
18193   if (dynamic_syminfo)
18194     {
18195       free (dynamic_syminfo);
18196       dynamic_syminfo = NULL;
18197     }
18198
18199   if (dynamic_section)
18200     {
18201       free (dynamic_section);
18202       dynamic_section = NULL;
18203     }
18204
18205   if (section_headers_groups)
18206     {
18207       free (section_headers_groups);
18208       section_headers_groups = NULL;
18209     }
18210
18211   if (section_groups)
18212     {
18213       struct group_list * g;
18214       struct group_list * next;
18215
18216       for (i = 0; i < group_count; i++)
18217         {
18218           for (g = section_groups [i].root; g != NULL; g = next)
18219             {
18220               next = g->next;
18221               free (g);
18222             }
18223         }
18224
18225       free (section_groups);
18226       section_groups = NULL;
18227     }
18228
18229   free_debug_memory ();
18230
18231   return res;
18232 }
18233
18234 /* Process an ELF archive.
18235    On entry the file is positioned just after the ARMAG string.
18236    Returns TRUE upon success, FALSE otherwise.  */
18237
18238 static bfd_boolean
18239 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18240 {
18241   struct archive_info arch;
18242   struct archive_info nested_arch;
18243   size_t got;
18244   bfd_boolean ret = TRUE;
18245
18246   show_name = TRUE;
18247
18248   /* The ARCH structure is used to hold information about this archive.  */
18249   arch.file_name = NULL;
18250   arch.file = NULL;
18251   arch.index_array = NULL;
18252   arch.sym_table = NULL;
18253   arch.longnames = NULL;
18254
18255   /* The NESTED_ARCH structure is used as a single-item cache of information
18256      about a nested archive (when members of a thin archive reside within
18257      another regular archive file).  */
18258   nested_arch.file_name = NULL;
18259   nested_arch.file = NULL;
18260   nested_arch.index_array = NULL;
18261   nested_arch.sym_table = NULL;
18262   nested_arch.longnames = NULL;
18263
18264   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18265     {
18266       ret = FALSE;
18267       goto out;
18268     }
18269
18270   if (do_archive_index)
18271     {
18272       if (arch.sym_table == NULL)
18273         error (_("%s: unable to dump the index as none was found\n"), file_name);
18274       else
18275         {
18276           unsigned long i, l;
18277           unsigned long current_pos;
18278
18279           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18280                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18281           current_pos = ftell (file);
18282
18283           for (i = l = 0; i < arch.index_num; i++)
18284             {
18285               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18286                 {
18287                   char * member_name;
18288
18289                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18290
18291                   if (member_name != NULL)
18292                     {
18293                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18294
18295                       if (qualified_name != NULL)
18296                         {
18297                           printf (_("Contents of binary %s at offset "), qualified_name);
18298                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18299                           putchar ('\n');
18300                           free (qualified_name);
18301                         }
18302                     }
18303                 }
18304
18305               if (l >= arch.sym_size)
18306                 {
18307                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18308                          file_name);
18309                   ret = FALSE;
18310                   break;
18311                 }
18312               /* PR 17531: file: 0b6630b2.  */
18313               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18314               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18315             }
18316
18317           if (arch.uses_64bit_indicies)
18318             l = (l + 7) & ~ 7;
18319           else
18320             l += l & 1;
18321
18322           if (l < arch.sym_size)
18323             {
18324               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18325                      file_name, arch.sym_size - l);
18326               ret = FALSE;
18327             }
18328
18329           if (fseek (file, current_pos, SEEK_SET) != 0)
18330             {
18331               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18332               ret = FALSE;
18333               goto out;
18334             }
18335         }
18336
18337       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18338           && !do_segments && !do_header && !do_dump && !do_version
18339           && !do_histogram && !do_debugging && !do_arch && !do_notes
18340           && !do_section_groups && !do_dyn_syms)
18341         {
18342           ret = TRUE; /* Archive index only.  */
18343           goto out;
18344         }
18345     }
18346
18347   while (1)
18348     {
18349       char * name;
18350       size_t namelen;
18351       char * qualified_name;
18352
18353       /* Read the next archive header.  */
18354       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18355         {
18356           error (_("%s: failed to seek to next archive header\n"), file_name);
18357           return FALSE;
18358         }
18359       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18360       if (got != sizeof arch.arhdr)
18361         {
18362           if (got == 0)
18363             break;
18364           error (_("%s: failed to read archive header\n"), file_name);
18365           ret = FALSE;
18366           break;
18367         }
18368       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18369         {
18370           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18371           ret = FALSE;
18372           break;
18373         }
18374
18375       arch.next_arhdr_offset += sizeof arch.arhdr;
18376
18377       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18378       if (archive_file_size & 01)
18379         ++archive_file_size;
18380
18381       name = get_archive_member_name (&arch, &nested_arch);
18382       if (name == NULL)
18383         {
18384           error (_("%s: bad archive file name\n"), file_name);
18385           ret = FALSE;
18386           break;
18387         }
18388       namelen = strlen (name);
18389
18390       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18391       if (qualified_name == NULL)
18392         {
18393           error (_("%s: bad archive file name\n"), file_name);
18394           ret = FALSE;
18395           break;
18396         }
18397
18398       if (is_thin_archive && arch.nested_member_origin == 0)
18399         {
18400           /* This is a proxy for an external member of a thin archive.  */
18401           FILE * member_file;
18402           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18403
18404           if (member_file_name == NULL)
18405             {
18406               ret = FALSE;
18407               break;
18408             }
18409
18410           member_file = fopen (member_file_name, "rb");
18411           if (member_file == NULL)
18412             {
18413               error (_("Input file '%s' is not readable.\n"), member_file_name);
18414               free (member_file_name);
18415               ret = FALSE;
18416               break;
18417             }
18418
18419           archive_file_offset = arch.nested_member_origin;
18420
18421           if (! process_object (qualified_name, member_file))
18422             ret = FALSE;
18423
18424           fclose (member_file);
18425           free (member_file_name);
18426         }
18427       else if (is_thin_archive)
18428         {
18429           /* PR 15140: Allow for corrupt thin archives.  */
18430           if (nested_arch.file == NULL)
18431             {
18432               error (_("%s: contains corrupt thin archive: %s\n"),
18433                      file_name, name);
18434               ret = FALSE;
18435               break;
18436             }
18437
18438           /* This is a proxy for a member of a nested archive.  */
18439           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18440
18441           /* The nested archive file will have been opened and setup by
18442              get_archive_member_name.  */
18443           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18444             {
18445               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18446               ret = FALSE;
18447               break;
18448             }
18449
18450           if (! process_object (qualified_name, nested_arch.file))
18451             ret = FALSE;
18452         }
18453       else
18454         {
18455           archive_file_offset = arch.next_arhdr_offset;
18456           arch.next_arhdr_offset += archive_file_size;
18457
18458           if (! process_object (qualified_name, file))
18459             ret = FALSE;
18460         }
18461
18462       if (dump_sects != NULL)
18463         {
18464           free (dump_sects);
18465           dump_sects = NULL;
18466           num_dump_sects = 0;
18467         }
18468
18469       free (qualified_name);
18470     }
18471
18472  out:
18473   if (nested_arch.file != NULL)
18474     fclose (nested_arch.file);
18475   release_archive (&nested_arch);
18476   release_archive (&arch);
18477
18478   return ret;
18479 }
18480
18481 static bfd_boolean
18482 process_file (char * file_name)
18483 {
18484   FILE * file;
18485   struct stat statbuf;
18486   char armag[SARMAG];
18487   bfd_boolean ret = TRUE;
18488
18489   if (stat (file_name, &statbuf) < 0)
18490     {
18491       if (errno == ENOENT)
18492         error (_("'%s': No such file\n"), file_name);
18493       else
18494         error (_("Could not locate '%s'.  System error message: %s\n"),
18495                file_name, strerror (errno));
18496       return FALSE;
18497     }
18498
18499   if (! S_ISREG (statbuf.st_mode))
18500     {
18501       error (_("'%s' is not an ordinary file\n"), file_name);
18502       return FALSE;
18503     }
18504
18505   file = fopen (file_name, "rb");
18506   if (file == NULL)
18507     {
18508       error (_("Input file '%s' is not readable.\n"), file_name);
18509       return FALSE;
18510     }
18511
18512   if (fread (armag, SARMAG, 1, file) != 1)
18513     {
18514       error (_("%s: Failed to read file's magic number\n"), file_name);
18515       fclose (file);
18516       return FALSE;
18517     }
18518
18519   current_file_size = (bfd_size_type) statbuf.st_size;
18520
18521   if (memcmp (armag, ARMAG, SARMAG) == 0)
18522     {
18523       if (! process_archive (file_name, file, FALSE))
18524         ret = FALSE;
18525     }
18526   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18527     {
18528       if ( ! process_archive (file_name, file, TRUE))
18529         ret = FALSE;
18530     }
18531   else
18532     {
18533       if (do_archive_index)
18534         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18535                file_name);
18536
18537       rewind (file);
18538       archive_file_size = archive_file_offset = 0;
18539
18540       if (! process_object (file_name, file))
18541         ret = FALSE;
18542     }
18543
18544   fclose (file);
18545   current_file_size = 0;
18546
18547   return ret;
18548 }
18549
18550 #ifdef SUPPORT_DISASSEMBLY
18551 /* Needed by the i386 disassembler.  For extra credit, someone could
18552    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18553    symbols.  */
18554
18555 void
18556 print_address (unsigned int addr, FILE * outfile)
18557 {
18558   fprintf (outfile,"0x%8.8x", addr);
18559 }
18560
18561 /* Needed by the i386 disassembler.  */
18562 void
18563 db_task_printsym (unsigned int addr)
18564 {
18565   print_address (addr, stderr);
18566 }
18567 #endif
18568
18569 int
18570 main (int argc, char ** argv)
18571 {
18572   int err;
18573
18574 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18575   setlocale (LC_MESSAGES, "");
18576 #endif
18577 #if defined (HAVE_SETLOCALE)
18578   setlocale (LC_CTYPE, "");
18579 #endif
18580   bindtextdomain (PACKAGE, LOCALEDIR);
18581   textdomain (PACKAGE);
18582
18583   expandargv (&argc, &argv);
18584
18585   parse_args (argc, argv);
18586
18587   if (num_dump_sects > 0)
18588     {
18589       /* Make a copy of the dump_sects array.  */
18590       cmdline_dump_sects = (dump_type *)
18591           malloc (num_dump_sects * sizeof (* dump_sects));
18592       if (cmdline_dump_sects == NULL)
18593         error (_("Out of memory allocating dump request table.\n"));
18594       else
18595         {
18596           memcpy (cmdline_dump_sects, dump_sects,
18597                   num_dump_sects * sizeof (* dump_sects));
18598           num_cmdline_dump_sects = num_dump_sects;
18599         }
18600     }
18601
18602   if (optind < (argc - 1))
18603     show_name = TRUE;
18604   else if (optind >= argc)
18605     {
18606       warn (_("Nothing to do.\n"));
18607       usage (stderr);
18608     }
18609
18610   err = FALSE;
18611   while (optind < argc)
18612     if (! process_file (argv[optind++]))
18613       err = TRUE;
18614
18615   if (dump_sects != NULL)
18616     free (dump_sects);
18617   if (cmdline_dump_sects != NULL)
18618     free (cmdline_dump_sects);
18619
18620   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18621 }