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 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 325    BFD_FMA_FMT can't be used in translated strings.  */
 326
 327 static const char *
 328 bfd_vmatoa (char *fmtch, bfd_vma value)
 329 {
 330   /* bfd_vmatoa is used more then once in a printf call for output.
 331      Cycle through an array of buffers.  */
 332   static int buf_pos = 0;
 333   static struct bfd_vmatoa_buf
 334   {
 335     char place[64];
 336   } buf[4];
 337   char *ret;
 338   char fmt[32];
 339
 340   ret = buf[buf_pos++].place;
 341   buf_pos %= ARRAY_SIZE (buf);
 342
 343   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 344   snprintf (ret, sizeof (buf[0].place), fmt, value);
 345   return ret;
 346 }
 347
 348 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
 349    the offset of the current archive member, if we are examining an archive.
 350    Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer
 351    using malloc and fill that.  In either case return the pointer to the start of
 352    the retrieved data or NULL if something went wrong.  If something does go wrong
 353    and REASON is not NULL then emit an error message using REASON as part of the
 354    context.  */
 355
 356 static void *
 357 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
 358           bfd_size_type nmemb, const char * reason)
 359 {
 360   void * mvar;
 361   bfd_size_type amt = size * nmemb;
 362
 363   if (size == 0 || nmemb == 0)
 364     return NULL;
 365
 366   /* If the size_t type is smaller than the bfd_size_type, eg because
 367      you are building a 32-bit tool on a 64-bit host, then make sure
 368      that when the sizes are cast to (size_t) no information is lost.  */
 369   if (sizeof (size_t) < sizeof (bfd_size_type)
 370       && (   (bfd_size_type) ((size_t) size) != size
 371           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 372     {
 373       if (reason)
 374         error (_("Size truncation prevents reading %s"
 375                  " elements of size %s for %s\n"),
 376                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 377       return NULL;
 378     }
 379
 380   /* Check for size overflow.  */
 381   if (amt < nmemb)
 382     {
 383       if (reason)
 384         error (_("Size overflow prevents reading %s"
 385                  " elements of size %s for %s\n"),
 386                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 387       return NULL;
 388     }
 389
 390   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 391      attempting to allocate memory when the read is bound to fail.  */
 392   if (amt > current_file_size
 393       || offset + archive_file_offset + amt > current_file_size)
 394     {
 395       if (reason)
 396         error (_("Reading %s bytes extends past end of file for %s\n"),
 397                bfd_vmatoa ("u", amt), reason);
 398       return NULL;
 399     }
 400
 401   if (fseek (file, archive_file_offset + offset, SEEK_SET))
 402     {
 403       if (reason)
 404         error (_("Unable to seek to 0x%lx for %s\n"),
 405                archive_file_offset + offset, reason);
 406       return NULL;
 407     }
 408
 409   mvar = var;
 410   if (mvar == NULL)
 411     {
 412       /* Check for overflow.  */
 413       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 414         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 415         mvar = malloc ((size_t) amt + 1);
 416
 417       if (mvar == NULL)
 418         {
 419           if (reason)
 420             error (_("Out of memory allocating %s bytes for %s\n"),
 421                    bfd_vmatoa ("u", amt), reason);
 422           return NULL;
 423         }
 424
 425       ((char *) mvar)[amt] = '\0';
 426     }
 427
 428   if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
 429     {
 430       if (reason)
 431         error (_("Unable to read in %s bytes of %s\n"),
 432                bfd_vmatoa ("u", amt), reason);
 433       if (mvar != var)
 434         free (mvar);
 435       return NULL;
 436     }
 437
 438   return mvar;
 439 }
 440
 441 /* Print a VMA value in the MODE specified.
 442    Returns the number of characters displayed.  */
 443
 444 static unsigned int
 445 print_vma (bfd_vma vma, print_mode mode)
 446 {
 447   unsigned int nc = 0;
 448
 449   switch (mode)
 450     {
 451     case FULL_HEX:
 452       nc = printf ("0x");
 453       /* Fall through.  */
 454     case LONG_HEX:
 455 #ifdef BFD64
 456       if (is_32bit_elf)
 457         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 458 #endif
 459       printf_vma (vma);
 460       return nc + 16;
 461
 462     case DEC_5:
 463       if (vma <= 99999)
 464         return printf ("%5" BFD_VMA_FMT "d", vma);
 465       /* Fall through.  */
 466     case PREFIX_HEX:
 467       nc = printf ("0x");
 468       /* Fall through.  */
 469     case HEX:
 470       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 471
 472     case DEC:
 473       return printf ("%" BFD_VMA_FMT "d", vma);
 474
 475     case UNSIGNED:
 476       return printf ("%" BFD_VMA_FMT "u", vma);
 477
 478     default:
 479       /* FIXME: Report unrecognised mode ?  */
 480       return 0;
 481     }
 482 }
 483
 484 /* Display a symbol on stdout.  Handles the display of control characters and
 485    multibye characters (assuming the host environment supports them).
 486
 487    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 488
 489    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 490    padding as necessary.
 491
 492    Returns the number of emitted characters.  */
 493
 494 static unsigned int
 495 print_symbol (signed int width, const char *symbol)
 496 {
 497   bfd_boolean extra_padding = FALSE;
 498   signed int num_printed = 0;
 499 #ifdef HAVE_MBSTATE_T
 500   mbstate_t state;
 501 #endif
 502   unsigned int width_remaining;
 503
 504   if (width < 0)
 505     {
 506       /* Keep the width positive.  This helps the code below.  */
 507       width = - width;
 508       extra_padding = TRUE;
 509     }
 510   assert (width != 0);
 511
 512   if (do_wide)
 513     /* Set the remaining width to a very large value.
 514        This simplifies the code below.  */
 515     width_remaining = INT_MAX;
 516   else
 517     width_remaining = width;
 518
 519 #ifdef HAVE_MBSTATE_T
 520   /* Initialise the multibyte conversion state.  */
 521   memset (& state, 0, sizeof (state));
 522 #endif
 523
 524   while (width_remaining)
 525     {
 526       size_t  n;
 527       const char c = *symbol++;
 528
 529       if (c == 0)
 530         break;
 531
 532       /* Do not print control characters directly as they can affect terminal
 533          settings.  Such characters usually appear in the names generated
 534          by the assembler for local labels.  */
 535       if (ISCNTRL (c))
 536         {
 537           if (width_remaining < 2)
 538             break;
 539
 540           printf ("^%c", c + 0x40);
 541           width_remaining -= 2;
 542           num_printed += 2;
 543         }
 544       else if (ISPRINT (c))
 545         {
 546           putchar (c);
 547           width_remaining --;
 548           num_printed ++;
 549         }
 550       else
 551         {
 552 #ifdef HAVE_MBSTATE_T
 553           wchar_t w;
 554 #endif
 555           /* Let printf do the hard work of displaying multibyte characters.  */
 556           printf ("%.1s", symbol - 1);
 557           width_remaining --;
 558           num_printed ++;
 559
 560 #ifdef HAVE_MBSTATE_T
 561           /* Try to find out how many bytes made up the character that was
 562              just printed.  Advance the symbol pointer past the bytes that
 563              were displayed.  */
 564           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 565 #else
 566           n = 1;
 567 #endif
 568           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 569             symbol += (n - 1);
 570         }
 571     }
 572
 573   if (extra_padding && num_printed < width)
 574     {
 575       /* Fill in the remaining spaces.  */
 576       printf ("%-*s", width - num_printed, " ");
 577       num_printed = width;
 578     }
 579
 580   return num_printed;
 581 }
 582
 583 /* Returns a pointer to a static buffer containing a printable version of
 584    the given section's name.  Like print_symbol, except that it does not try
 585    to print multibyte characters, it just interprets them as hex values.  */
 586
 587 static const char *
 588 printable_section_name (const Elf_Internal_Shdr * sec)
 589 {
 590 #define MAX_PRINT_SEC_NAME_LEN 128
 591   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 592   const char * name = SECTION_NAME (sec);
 593   char *       buf = sec_name_buf;
 594   char         c;
 595   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 596
 597   while ((c = * name ++) != 0)
 598     {
 599       if (ISCNTRL (c))
 600         {
 601           if (remaining < 2)
 602             break;
 603
 604           * buf ++ = '^';
 605           * buf ++ = c + 0x40;
 606           remaining -= 2;
 607         }
 608       else if (ISPRINT (c))
 609         {
 610           * buf ++ = c;
 611           remaining -= 1;
 612         }
 613       else
 614         {
 615           static char hex[17] = "0123456789ABCDEF";
 616
 617           if (remaining < 4)
 618             break;
 619           * buf ++ = '<';
 620           * buf ++ = hex[(c & 0xf0) >> 4];
 621           * buf ++ = hex[c & 0x0f];
 622           * buf ++ = '>';
 623           remaining -= 4;
 624         }
 625
 626       if (remaining == 0)
 627         break;
 628     }
 629
 630   * buf = 0;
 631   return sec_name_buf;
 632 }
 633
 634 static const char *
 635 printable_section_name_from_index (unsigned long ndx)
 636 {
 637   if (ndx >= elf_header.e_shnum)
 638     return _("<corrupt>");
 639
 640   return printable_section_name (section_headers + ndx);
 641 }
 642
 643 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 644
 645 static Elf_Internal_Shdr *
 646 find_section (const char * name)
 647 {
 648   unsigned int i;
 649
 650   for (i = 0; i < elf_header.e_shnum; i++)
 651     if (streq (SECTION_NAME (section_headers + i), name))
 652       return section_headers + i;
 653
 654   return NULL;
 655 }
 656
 657 /* Return a pointer to a section containing ADDR, or NULL if no such
 658    section exists.  */
 659
 660 static Elf_Internal_Shdr *
 661 find_section_by_address (bfd_vma addr)
 662 {
 663   unsigned int i;
 664
 665   for (i = 0; i < elf_header.e_shnum; i++)
 666     {
 667       Elf_Internal_Shdr *sec = section_headers + i;
 668       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 669         return sec;
 670     }
 671
 672   return NULL;
 673 }
 674
 675 static Elf_Internal_Shdr *
 676 find_section_by_type (unsigned int type)
 677 {
 678   unsigned int i;
 679
 680   for (i = 0; i < elf_header.e_shnum; i++)
 681     {
 682       Elf_Internal_Shdr *sec = section_headers + i;
 683       if (sec->sh_type == type)
 684         return sec;
 685     }
 686
 687   return NULL;
 688 }
 689
 690 /* Return a pointer to section NAME, or NULL if no such section exists,
 691    restricted to the list of sections given in SET.  */
 692
 693 static Elf_Internal_Shdr *
 694 find_section_in_set (const char * name, unsigned int * set)
 695 {
 696   unsigned int i;
 697
 698   if (set != NULL)
 699     {
 700       while ((i = *set++) > 0)
 701         {
 702           /* See PR 21156 for a reproducer.  */
 703           if (i >= elf_header.e_shnum)
 704             continue; /* FIXME: Should we issue an error message ?  */
 705
 706           if (streq (SECTION_NAME (section_headers + i), name))
 707             return section_headers + i;
 708         }
 709     }
 710
 711   return find_section (name);
 712 }
 713
 714 /* Read an unsigned LEB128 encoded value from DATA.
 715    Set *LENGTH_RETURN to the number of bytes read.  */
 716
 717 static inline unsigned long
 718 read_uleb128 (unsigned char * data,
 719               unsigned int * length_return,
 720               const unsigned char * const end)
 721 {
 722   return read_leb128 (data, length_return, FALSE, end);
 723 }
 724
 725 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 726    This OS has so many departures from the ELF standard that we test it at
 727    many places.  */
 728
 729 static inline bfd_boolean
 730 is_ia64_vms (void)
 731 {
 732   return elf_header.e_machine == EM_IA_64
 733     && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 734 }
 735
 736 /* Guess the relocation size commonly used by the specific machines.  */
 737
 738 static bfd_boolean
 739 guess_is_rela (unsigned int e_machine)
 740 {
 741   switch (e_machine)
 742     {
 743       /* Targets that use REL relocations.  */
 744     case EM_386:
 745     case EM_IAMCU:
 746     case EM_960:
 747     case EM_ARM:
 748     case EM_D10V:
 749     case EM_CYGNUS_D10V:
 750     case EM_DLX:
 751     case EM_MIPS:
 752     case EM_MIPS_RS3_LE:
 753     case EM_CYGNUS_M32R:
 754     case EM_SCORE:
 755     case EM_XGATE:
 756       return FALSE;
 757
 758       /* Targets that use RELA relocations.  */
 759     case EM_68K:
 760     case EM_860:
 761     case EM_AARCH64:
 762     case EM_ADAPTEVA_EPIPHANY:
 763     case EM_ALPHA:
 764     case EM_ALTERA_NIOS2:
 765     case EM_ARC:
 766     case EM_ARC_COMPACT:
 767     case EM_ARC_COMPACT2:
 768     case EM_AVR:
 769     case EM_AVR_OLD:
 770     case EM_BLACKFIN:
 771     case EM_CR16:
 772     case EM_CRIS:
 773     case EM_CRX:
 774     case EM_D30V:
 775     case EM_CYGNUS_D30V:
 776     case EM_FR30:
 777     case EM_FT32:
 778     case EM_CYGNUS_FR30:
 779     case EM_CYGNUS_FRV:
 780     case EM_H8S:
 781     case EM_H8_300:
 782     case EM_H8_300H:
 783     case EM_IA_64:
 784     case EM_IP2K:
 785     case EM_IP2K_OLD:
 786     case EM_IQ2000:
 787     case EM_LATTICEMICO32:
 788     case EM_M32C_OLD:
 789     case EM_M32C:
 790     case EM_M32R:
 791     case EM_MCORE:
 792     case EM_CYGNUS_MEP:
 793     case EM_METAG:
 794     case EM_MMIX:
 795     case EM_MN10200:
 796     case EM_CYGNUS_MN10200:
 797     case EM_MN10300:
 798     case EM_CYGNUS_MN10300:
 799     case EM_MOXIE:
 800     case EM_MSP430:
 801     case EM_MSP430_OLD:
 802     case EM_MT:
 803     case EM_NDS32:
 804     case EM_NIOS32:
 805     case EM_OR1K:
 806     case EM_PPC64:
 807     case EM_PPC:
 808     case EM_TI_PRU:
 809     case EM_RISCV:
 810     case EM_RL78:
 811     case EM_RX:
 812     case EM_S390:
 813     case EM_S390_OLD:
 814     case EM_SH:
 815     case EM_SPARC:
 816     case EM_SPARC32PLUS:
 817     case EM_SPARCV9:
 818     case EM_SPU:
 819     case EM_TI_C6000:
 820     case EM_TILEGX:
 821     case EM_TILEPRO:
 822     case EM_V800:
 823     case EM_V850:
 824     case EM_CYGNUS_V850:
 825     case EM_VAX:
 826     case EM_VISIUM:
 827     case EM_X86_64:
 828     case EM_L1OM:
 829     case EM_K1OM:
 830     case EM_XSTORMY16:
 831     case EM_XTENSA:
 832     case EM_XTENSA_OLD:
 833     case EM_MICROBLAZE:
 834     case EM_MICROBLAZE_OLD:
 835     case EM_WEBASSEMBLY:
 836       return TRUE;
 837
 838     case EM_68HC05:
 839     case EM_68HC08:
 840     case EM_68HC11:
 841     case EM_68HC16:
 842     case EM_FX66:
 843     case EM_ME16:
 844     case EM_MMA:
 845     case EM_NCPU:
 846     case EM_NDR1:
 847     case EM_PCP:
 848     case EM_ST100:
 849     case EM_ST19:
 850     case EM_ST7:
 851     case EM_ST9PLUS:
 852     case EM_STARCORE:
 853     case EM_SVX:
 854     case EM_TINYJ:
 855     default:
 856       warn (_("Don't know about relocations on this machine architecture\n"));
 857       return FALSE;
 858     }
 859 }
 860
 861 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 862    Returns TRUE upon success, FALSE otherwise.  If successful then a
 863    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 864    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 865    responsibility to free the allocated buffer.  */
 866
 867 static bfd_boolean
 868 slurp_rela_relocs (FILE * file,
 869                    unsigned long rel_offset,
 870                    unsigned long rel_size,
 871                    Elf_Internal_Rela ** relasp,
 872                    unsigned long * nrelasp)
 873 {
 874   Elf_Internal_Rela * relas;
 875   size_t nrelas;
 876   unsigned int i;
 877
 878   if (is_32bit_elf)
 879     {
 880       Elf32_External_Rela * erelas;
 881
 882       erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
 883                                                  rel_size, _("32-bit relocation data"));
 884       if (!erelas)
 885         return FALSE;
 886
 887       nrelas = rel_size / sizeof (Elf32_External_Rela);
 888
 889       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 890                                              sizeof (Elf_Internal_Rela));
 891
 892       if (relas == NULL)
 893         {
 894           free (erelas);
 895           error (_("out of memory parsing relocs\n"));
 896           return FALSE;
 897         }
 898
 899       for (i = 0; i < nrelas; i++)
 900         {
 901           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 902           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 903           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 904         }
 905
 906       free (erelas);
 907     }
 908   else
 909     {
 910       Elf64_External_Rela * erelas;
 911
 912       erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
 913                                                  rel_size, _("64-bit relocation data"));
 914       if (!erelas)
 915         return FALSE;
 916
 917       nrelas = rel_size / sizeof (Elf64_External_Rela);
 918
 919       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 920                                              sizeof (Elf_Internal_Rela));
 921
 922       if (relas == NULL)
 923         {
 924           free (erelas);
 925           error (_("out of memory parsing relocs\n"));
 926           return FALSE;
 927         }
 928
 929       for (i = 0; i < nrelas; i++)
 930         {
 931           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 932           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 933           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 934
 935           /* The #ifdef BFD64 below is to prevent a compile time
 936              warning.  We know that if we do not have a 64 bit data
 937              type that we will never execute this code anyway.  */
 938 #ifdef BFD64
 939           if (elf_header.e_machine == EM_MIPS
 940               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
 941             {
 942               /* In little-endian objects, r_info isn't really a
 943                  64-bit little-endian value: it has a 32-bit
 944                  little-endian symbol index followed by four
 945                  individual byte fields.  Reorder INFO
 946                  accordingly.  */
 947               bfd_vma inf = relas[i].r_info;
 948               inf = (((inf & 0xffffffff) << 32)
 949                       | ((inf >> 56) & 0xff)
 950                       | ((inf >> 40) & 0xff00)
 951                       | ((inf >> 24) & 0xff0000)
 952                       | ((inf >> 8) & 0xff000000));
 953               relas[i].r_info = inf;
 954             }
 955 #endif /* BFD64 */
 956         }
 957
 958       free (erelas);
 959     }
 960
 961   *relasp = relas;
 962   *nrelasp = nrelas;
 963   return TRUE;
 964 }
 965
 966 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
 967    Returns TRUE upon success, FALSE otherwise.  If successful then a
 968    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 969    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 970    responsibility to free the allocated buffer.  */
 971
 972 static bfd_boolean
 973 slurp_rel_relocs (FILE * file,
 974                   unsigned long rel_offset,
 975                   unsigned long rel_size,
 976                   Elf_Internal_Rela ** relsp,
 977                   unsigned long * nrelsp)
 978 {
 979   Elf_Internal_Rela * rels;
 980   size_t nrels;
 981   unsigned int i;
 982
 983   if (is_32bit_elf)
 984     {
 985       Elf32_External_Rel * erels;
 986
 987       erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
 988                                                rel_size, _("32-bit relocation data"));
 989       if (!erels)
 990         return FALSE;
 991
 992       nrels = rel_size / sizeof (Elf32_External_Rel);
 993
 994       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
 995
 996       if (rels == NULL)
 997         {
 998           free (erels);
 999           error (_("out of memory parsing relocs\n"));
1000           return FALSE;
1001         }
1002
1003       for (i = 0; i < nrels; i++)
1004         {
1005           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1006           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1007           rels[i].r_addend = 0;
1008         }
1009
1010       free (erels);
1011     }
1012   else
1013     {
1014       Elf64_External_Rel * erels;
1015
1016       erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
1017                                                rel_size, _("64-bit relocation data"));
1018       if (!erels)
1019         return FALSE;
1020
1021       nrels = rel_size / sizeof (Elf64_External_Rel);
1022
1023       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1024
1025       if (rels == NULL)
1026         {
1027           free (erels);
1028           error (_("out of memory parsing relocs\n"));
1029           return FALSE;
1030         }
1031
1032       for (i = 0; i < nrels; i++)
1033         {
1034           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1035           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1036           rels[i].r_addend = 0;
1037
1038           /* The #ifdef BFD64 below is to prevent a compile time
1039              warning.  We know that if we do not have a 64 bit data
1040              type that we will never execute this code anyway.  */
1041 #ifdef BFD64
1042           if (elf_header.e_machine == EM_MIPS
1043               && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1044             {
1045               /* In little-endian objects, r_info isn't really a
1046                  64-bit little-endian value: it has a 32-bit
1047                  little-endian symbol index followed by four
1048                  individual byte fields.  Reorder INFO
1049                  accordingly.  */
1050               bfd_vma inf = rels[i].r_info;
1051               inf = (((inf & 0xffffffff) << 32)
1052                      | ((inf >> 56) & 0xff)
1053                      | ((inf >> 40) & 0xff00)
1054                      | ((inf >> 24) & 0xff0000)
1055                      | ((inf >> 8) & 0xff000000));
1056               rels[i].r_info = inf;
1057             }
1058 #endif /* BFD64 */
1059         }
1060
1061       free (erels);
1062     }
1063
1064   *relsp = rels;
1065   *nrelsp = nrels;
1066   return TRUE;
1067 }
1068
1069 /* Returns the reloc type extracted from the reloc info field.  */
1070
1071 static unsigned int
1072 get_reloc_type (bfd_vma reloc_info)
1073 {
1074   if (is_32bit_elf)
1075     return ELF32_R_TYPE (reloc_info);
1076
1077   switch (elf_header.e_machine)
1078     {
1079     case EM_MIPS:
1080       /* Note: We assume that reloc_info has already been adjusted for us.  */
1081       return ELF64_MIPS_R_TYPE (reloc_info);
1082
1083     case EM_SPARCV9:
1084       return ELF64_R_TYPE_ID (reloc_info);
1085
1086     default:
1087       return ELF64_R_TYPE (reloc_info);
1088     }
1089 }
1090
1091 /* Return the symbol index extracted from the reloc info field.  */
1092
1093 static bfd_vma
1094 get_reloc_symindex (bfd_vma reloc_info)
1095 {
1096   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1097 }
1098
1099 static inline bfd_boolean
1100 uses_msp430x_relocs (void)
1101 {
1102   return
1103     elf_header.e_machine == EM_MSP430 /* Paranoia.  */
1104     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1105     && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1106         /* TI compiler uses ELFOSABI_NONE.  */
1107         || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1108 }
1109
1110 /* Display the contents of the relocation data found at the specified
1111    offset.  */
1112
1113 static bfd_boolean
1114 dump_relocations (FILE * file,
1115                   unsigned long rel_offset,
1116                   unsigned long rel_size,
1117                   Elf_Internal_Sym * symtab,
1118                   unsigned long nsyms,
1119                   char * strtab,
1120                   unsigned long strtablen,
1121                   int is_rela,
1122                   bfd_boolean is_dynsym)
1123 {
1124   unsigned long i;
1125   Elf_Internal_Rela * rels;
1126   bfd_boolean res = TRUE;
1127
1128   if (is_rela == UNKNOWN)
1129     is_rela = guess_is_rela (elf_header.e_machine);
1130
1131   if (is_rela)
1132     {
1133       if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1134         return FALSE;
1135     }
1136   else
1137     {
1138       if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1139         return FALSE;
1140     }
1141
1142   if (is_32bit_elf)
1143     {
1144       if (is_rela)
1145         {
1146           if (do_wide)
1147             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1148           else
1149             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1150         }
1151       else
1152         {
1153           if (do_wide)
1154             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1155           else
1156             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1157         }
1158     }
1159   else
1160     {
1161       if (is_rela)
1162         {
1163           if (do_wide)
1164             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1165           else
1166             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1167         }
1168       else
1169         {
1170           if (do_wide)
1171             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1172           else
1173             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1174         }
1175     }
1176
1177   for (i = 0; i < rel_size; i++)
1178     {
1179       const char * rtype;
1180       bfd_vma offset;
1181       bfd_vma inf;
1182       bfd_vma symtab_index;
1183       bfd_vma type;
1184
1185       offset = rels[i].r_offset;
1186       inf    = rels[i].r_info;
1187
1188       type = get_reloc_type (inf);
1189       symtab_index = get_reloc_symindex  (inf);
1190
1191       if (is_32bit_elf)
1192         {
1193           printf ("%8.8lx  %8.8lx ",
1194                   (unsigned long) offset & 0xffffffff,
1195                   (unsigned long) inf & 0xffffffff);
1196         }
1197       else
1198         {
1199 #if BFD_HOST_64BIT_LONG
1200           printf (do_wide
1201                   ? "%16.16lx  %16.16lx "
1202                   : "%12.12lx  %12.12lx ",
1203                   offset, inf);
1204 #elif BFD_HOST_64BIT_LONG_LONG
1205 #ifndef __MSVCRT__
1206           printf (do_wide
1207                   ? "%16.16llx  %16.16llx "
1208                   : "%12.12llx  %12.12llx ",
1209                   offset, inf);
1210 #else
1211           printf (do_wide
1212                   ? "%16.16I64x  %16.16I64x "
1213                   : "%12.12I64x  %12.12I64x ",
1214                   offset, inf);
1215 #endif
1216 #else
1217           printf (do_wide
1218                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1219                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1220                   _bfd_int64_high (offset),
1221                   _bfd_int64_low (offset),
1222                   _bfd_int64_high (inf),
1223                   _bfd_int64_low (inf));
1224 #endif
1225         }
1226
1227       switch (elf_header.e_machine)
1228         {
1229         default:
1230           rtype = NULL;
1231           break;
1232
1233         case EM_AARCH64:
1234           rtype = elf_aarch64_reloc_type (type);
1235           break;
1236
1237         case EM_M32R:
1238         case EM_CYGNUS_M32R:
1239           rtype = elf_m32r_reloc_type (type);
1240           break;
1241
1242         case EM_386:
1243         case EM_IAMCU:
1244           rtype = elf_i386_reloc_type (type);
1245           break;
1246
1247         case EM_68HC11:
1248         case EM_68HC12:
1249           rtype = elf_m68hc11_reloc_type (type);
1250           break;
1251
1252         case EM_68K:
1253           rtype = elf_m68k_reloc_type (type);
1254           break;
1255
1256         case EM_960:
1257           rtype = elf_i960_reloc_type (type);
1258           break;
1259
1260         case EM_AVR:
1261         case EM_AVR_OLD:
1262           rtype = elf_avr_reloc_type (type);
1263           break;
1264
1265         case EM_OLD_SPARCV9:
1266         case EM_SPARC32PLUS:
1267         case EM_SPARCV9:
1268         case EM_SPARC:
1269           rtype = elf_sparc_reloc_type (type);
1270           break;
1271
1272         case EM_SPU:
1273           rtype = elf_spu_reloc_type (type);
1274           break;
1275
1276         case EM_V800:
1277           rtype = v800_reloc_type (type);
1278           break;
1279         case EM_V850:
1280         case EM_CYGNUS_V850:
1281           rtype = v850_reloc_type (type);
1282           break;
1283
1284         case EM_D10V:
1285         case EM_CYGNUS_D10V:
1286           rtype = elf_d10v_reloc_type (type);
1287           break;
1288
1289         case EM_D30V:
1290         case EM_CYGNUS_D30V:
1291           rtype = elf_d30v_reloc_type (type);
1292           break;
1293
1294         case EM_DLX:
1295           rtype = elf_dlx_reloc_type (type);
1296           break;
1297
1298         case EM_SH:
1299           rtype = elf_sh_reloc_type (type);
1300           break;
1301
1302         case EM_MN10300:
1303         case EM_CYGNUS_MN10300:
1304           rtype = elf_mn10300_reloc_type (type);
1305           break;
1306
1307         case EM_MN10200:
1308         case EM_CYGNUS_MN10200:
1309           rtype = elf_mn10200_reloc_type (type);
1310           break;
1311
1312         case EM_FR30:
1313         case EM_CYGNUS_FR30:
1314           rtype = elf_fr30_reloc_type (type);
1315           break;
1316
1317         case EM_CYGNUS_FRV:
1318           rtype = elf_frv_reloc_type (type);
1319           break;
1320
1321         case EM_FT32:
1322           rtype = elf_ft32_reloc_type (type);
1323           break;
1324
1325         case EM_MCORE:
1326           rtype = elf_mcore_reloc_type (type);
1327           break;
1328
1329         case EM_MMIX:
1330           rtype = elf_mmix_reloc_type (type);
1331           break;
1332
1333         case EM_MOXIE:
1334           rtype = elf_moxie_reloc_type (type);
1335           break;
1336
1337         case EM_MSP430:
1338           if (uses_msp430x_relocs ())
1339             {
1340               rtype = elf_msp430x_reloc_type (type);
1341               break;
1342             }
1343           /* Fall through.  */
1344         case EM_MSP430_OLD:
1345           rtype = elf_msp430_reloc_type (type);
1346           break;
1347
1348         case EM_NDS32:
1349           rtype = elf_nds32_reloc_type (type);
1350           break;
1351
1352         case EM_PPC:
1353           rtype = elf_ppc_reloc_type (type);
1354           break;
1355
1356         case EM_PPC64:
1357           rtype = elf_ppc64_reloc_type (type);
1358           break;
1359
1360         case EM_MIPS:
1361         case EM_MIPS_RS3_LE:
1362           rtype = elf_mips_reloc_type (type);
1363           break;
1364
1365         case EM_RISCV:
1366           rtype = elf_riscv_reloc_type (type);
1367           break;
1368
1369         case EM_ALPHA:
1370           rtype = elf_alpha_reloc_type (type);
1371           break;
1372
1373         case EM_ARM:
1374           rtype = elf_arm_reloc_type (type);
1375           break;
1376
1377         case EM_ARC:
1378         case EM_ARC_COMPACT:
1379         case EM_ARC_COMPACT2:
1380           rtype = elf_arc_reloc_type (type);
1381           break;
1382
1383         case EM_PARISC:
1384           rtype = elf_hppa_reloc_type (type);
1385           break;
1386
1387         case EM_H8_300:
1388         case EM_H8_300H:
1389         case EM_H8S:
1390           rtype = elf_h8_reloc_type (type);
1391           break;
1392
1393         case EM_OR1K:
1394           rtype = elf_or1k_reloc_type (type);
1395           break;
1396
1397         case EM_PJ:
1398         case EM_PJ_OLD:
1399           rtype = elf_pj_reloc_type (type);
1400           break;
1401         case EM_IA_64:
1402           rtype = elf_ia64_reloc_type (type);
1403           break;
1404
1405         case EM_CRIS:
1406           rtype = elf_cris_reloc_type (type);
1407           break;
1408
1409         case EM_860:
1410           rtype = elf_i860_reloc_type (type);
1411           break;
1412
1413         case EM_X86_64:
1414         case EM_L1OM:
1415         case EM_K1OM:
1416           rtype = elf_x86_64_reloc_type (type);
1417           break;
1418
1419         case EM_S370:
1420           rtype = i370_reloc_type (type);
1421           break;
1422
1423         case EM_S390_OLD:
1424         case EM_S390:
1425           rtype = elf_s390_reloc_type (type);
1426           break;
1427
1428         case EM_SCORE:
1429           rtype = elf_score_reloc_type (type);
1430           break;
1431
1432         case EM_XSTORMY16:
1433           rtype = elf_xstormy16_reloc_type (type);
1434           break;
1435
1436         case EM_CRX:
1437           rtype = elf_crx_reloc_type (type);
1438           break;
1439
1440         case EM_VAX:
1441           rtype = elf_vax_reloc_type (type);
1442           break;
1443
1444         case EM_VISIUM:
1445           rtype = elf_visium_reloc_type (type);
1446           break;
1447
1448         case EM_ADAPTEVA_EPIPHANY:
1449           rtype = elf_epiphany_reloc_type (type);
1450           break;
1451
1452         case EM_IP2K:
1453         case EM_IP2K_OLD:
1454           rtype = elf_ip2k_reloc_type (type);
1455           break;
1456
1457         case EM_IQ2000:
1458           rtype = elf_iq2000_reloc_type (type);
1459           break;
1460
1461         case EM_XTENSA_OLD:
1462         case EM_XTENSA:
1463           rtype = elf_xtensa_reloc_type (type);
1464           break;
1465
1466         case EM_LATTICEMICO32:
1467           rtype = elf_lm32_reloc_type (type);
1468           break;
1469
1470         case EM_M32C_OLD:
1471         case EM_M32C:
1472           rtype = elf_m32c_reloc_type (type);
1473           break;
1474
1475         case EM_MT:
1476           rtype = elf_mt_reloc_type (type);
1477           break;
1478
1479         case EM_BLACKFIN:
1480           rtype = elf_bfin_reloc_type (type);
1481           break;
1482
1483         case EM_CYGNUS_MEP:
1484           rtype = elf_mep_reloc_type (type);
1485           break;
1486
1487         case EM_CR16:
1488           rtype = elf_cr16_reloc_type (type);
1489           break;
1490
1491         case EM_MICROBLAZE:
1492         case EM_MICROBLAZE_OLD:
1493           rtype = elf_microblaze_reloc_type (type);
1494           break;
1495
1496         case EM_RL78:
1497           rtype = elf_rl78_reloc_type (type);
1498           break;
1499
1500         case EM_RX:
1501           rtype = elf_rx_reloc_type (type);
1502           break;
1503
1504         case EM_METAG:
1505           rtype = elf_metag_reloc_type (type);
1506           break;
1507
1508         case EM_XC16X:
1509         case EM_C166:
1510           rtype = elf_xc16x_reloc_type (type);
1511           break;
1512
1513         case EM_TI_C6000:
1514           rtype = elf_tic6x_reloc_type (type);
1515           break;
1516
1517         case EM_TILEGX:
1518           rtype = elf_tilegx_reloc_type (type);
1519           break;
1520
1521         case EM_TILEPRO:
1522           rtype = elf_tilepro_reloc_type (type);
1523           break;
1524
1525         case EM_WEBASSEMBLY:
1526           rtype = elf_wasm32_reloc_type (type);
1527           break;
1528
1529         case EM_XGATE:
1530           rtype = elf_xgate_reloc_type (type);
1531           break;
1532
1533         case EM_ALTERA_NIOS2:
1534           rtype = elf_nios2_reloc_type (type);
1535           break;
1536
1537         case EM_TI_PRU:
1538           rtype = elf_pru_reloc_type (type);
1539           break;
1540         }
1541
1542       if (rtype == NULL)
1543         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1544       else
1545         printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1546
1547       if (elf_header.e_machine == EM_ALPHA
1548           && rtype != NULL
1549           && streq (rtype, "R_ALPHA_LITUSE")
1550           && is_rela)
1551         {
1552           switch (rels[i].r_addend)
1553             {
1554             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1555             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1556             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1557             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1558             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1559             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1560             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1561             default: rtype = NULL;
1562             }
1563
1564           if (rtype)
1565             printf (" (%s)", rtype);
1566           else
1567             {
1568               putchar (' ');
1569               printf (_("<unknown addend: %lx>"),
1570                       (unsigned long) rels[i].r_addend);
1571               res = FALSE;
1572             }
1573         }
1574       else if (symtab_index)
1575         {
1576           if (symtab == NULL || symtab_index >= nsyms)
1577             {
1578               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1579               res = FALSE;
1580             }
1581           else
1582             {
1583               Elf_Internal_Sym * psym;
1584               const char * version_string;
1585               enum versioned_symbol_info sym_info;
1586               unsigned short vna_other;
1587
1588               psym = symtab + symtab_index;
1589
1590               version_string
1591                 = get_symbol_version_string (file, is_dynsym,
1592                                              strtab, strtablen,
1593                                              symtab_index,
1594                                              psym,
1595                                              &sym_info,
1596                                              &vna_other);
1597
1598               printf (" ");
1599
1600               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1601                 {
1602                   const char * name;
1603                   unsigned int len;
1604                   unsigned int width = is_32bit_elf ? 8 : 14;
1605
1606                   /* Relocations against GNU_IFUNC symbols do not use the value
1607                      of the symbol as the address to relocate against.  Instead
1608                      they invoke the function named by the symbol and use its
1609                      result as the address for relocation.
1610
1611                      To indicate this to the user, do not display the value of
1612                      the symbol in the "Symbols's Value" field.  Instead show
1613                      its name followed by () as a hint that the symbol is
1614                      invoked.  */
1615
1616                   if (strtab == NULL
1617                       || psym->st_name == 0
1618                       || psym->st_name >= strtablen)
1619                     name = "??";
1620                   else
1621                     name = strtab + psym->st_name;
1622
1623                   len = print_symbol (width, name);
1624                   if (version_string)
1625                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1626                             version_string);
1627                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1628                 }
1629               else
1630                 {
1631                   print_vma (psym->st_value, LONG_HEX);
1632
1633                   printf (is_32bit_elf ? "   " : " ");
1634                 }
1635
1636               if (psym->st_name == 0)
1637                 {
1638                   const char * sec_name = "<null>";
1639                   char name_buf[40];
1640
1641                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1642                     {
1643                       if (psym->st_shndx < elf_header.e_shnum)
1644                         sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1645                       else if (psym->st_shndx == SHN_ABS)
1646                         sec_name = "ABS";
1647                       else if (psym->st_shndx == SHN_COMMON)
1648                         sec_name = "COMMON";
1649                       else if ((elf_header.e_machine == EM_MIPS
1650                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1651                                || (elf_header.e_machine == EM_TI_C6000
1652                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1653                         sec_name = "SCOMMON";
1654                       else if (elf_header.e_machine == EM_MIPS
1655                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1656                         sec_name = "SUNDEF";
1657                       else if ((elf_header.e_machine == EM_X86_64
1658                                 || elf_header.e_machine == EM_L1OM
1659                                 || elf_header.e_machine == EM_K1OM)
1660                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1661                         sec_name = "LARGE_COMMON";
1662                       else if (elf_header.e_machine == EM_IA_64
1663                                && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1664                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1665                         sec_name = "ANSI_COM";
1666                       else if (is_ia64_vms ()
1667                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1668                         sec_name = "VMS_SYMVEC";
1669                       else
1670                         {
1671                           sprintf (name_buf, "<section 0x%x>",
1672                                    (unsigned int) psym->st_shndx);
1673                           sec_name = name_buf;
1674                         }
1675                     }
1676                   print_symbol (22, sec_name);
1677                 }
1678               else if (strtab == NULL)
1679                 printf (_("<string table index: %3ld>"), psym->st_name);
1680               else if (psym->st_name >= strtablen)
1681                 {
1682                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1683                   res = FALSE;
1684                 }
1685               else
1686                 {
1687                   print_symbol (22, strtab + psym->st_name);
1688                   if (version_string)
1689                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1690                             version_string);
1691                 }
1692
1693               if (is_rela)
1694                 {
1695                   bfd_vma off = rels[i].r_addend;
1696
1697                   if ((bfd_signed_vma) off < 0)
1698                     printf (" - %" BFD_VMA_FMT "x", - off);
1699                   else
1700                     printf (" + %" BFD_VMA_FMT "x", off);
1701                 }
1702             }
1703         }
1704       else if (is_rela)
1705         {
1706           bfd_vma off = rels[i].r_addend;
1707
1708           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1709           if ((bfd_signed_vma) off < 0)
1710             printf ("-%" BFD_VMA_FMT "x", - off);
1711           else
1712             printf ("%" BFD_VMA_FMT "x", off);
1713         }
1714
1715       if (elf_header.e_machine == EM_SPARCV9
1716           && rtype != NULL
1717           && streq (rtype, "R_SPARC_OLO10"))
1718         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1719
1720       putchar ('\n');
1721
1722 #ifdef BFD64
1723       if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1724         {
1725           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1726           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1727           const char * rtype2 = elf_mips_reloc_type (type2);
1728           const char * rtype3 = elf_mips_reloc_type (type3);
1729
1730           printf ("                    Type2: ");
1731
1732           if (rtype2 == NULL)
1733             printf (_("unrecognized: %-7lx"),
1734                     (unsigned long) type2 & 0xffffffff);
1735           else
1736             printf ("%-17.17s", rtype2);
1737
1738           printf ("\n                    Type3: ");
1739
1740           if (rtype3 == NULL)
1741             printf (_("unrecognized: %-7lx"),
1742                     (unsigned long) type3 & 0xffffffff);
1743           else
1744             printf ("%-17.17s", rtype3);
1745
1746           putchar ('\n');
1747         }
1748 #endif /* BFD64 */
1749     }
1750
1751   free (rels);
1752
1753   return res;
1754 }
1755
1756 static const char *
1757 get_mips_dynamic_type (unsigned long type)
1758 {
1759   switch (type)
1760     {
1761     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1762     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1763     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1764     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1765     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1766     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1767     case DT_MIPS_MSYM: return "MIPS_MSYM";
1768     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1769     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1770     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1771     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1772     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1773     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1774     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1775     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1776     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1777     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1778     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1779     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1780     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1781     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1782     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1783     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1784     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1785     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1786     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1787     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1788     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1789     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1790     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1791     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1792     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1793     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1794     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1795     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1796     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1797     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1798     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1799     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1800     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1801     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1802     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1803     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1804     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1805     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1806     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1807     default:
1808       return NULL;
1809     }
1810 }
1811
1812 static const char *
1813 get_sparc64_dynamic_type (unsigned long type)
1814 {
1815   switch (type)
1816     {
1817     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1818     default:
1819       return NULL;
1820     }
1821 }
1822
1823 static const char *
1824 get_ppc_dynamic_type (unsigned long type)
1825 {
1826   switch (type)
1827     {
1828     case DT_PPC_GOT:    return "PPC_GOT";
1829     case DT_PPC_OPT:    return "PPC_OPT";
1830     default:
1831       return NULL;
1832     }
1833 }
1834
1835 static const char *
1836 get_ppc64_dynamic_type (unsigned long type)
1837 {
1838   switch (type)
1839     {
1840     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1841     case DT_PPC64_OPD:    return "PPC64_OPD";
1842     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1843     case DT_PPC64_OPT:    return "PPC64_OPT";
1844     default:
1845       return NULL;
1846     }
1847 }
1848
1849 static const char *
1850 get_parisc_dynamic_type (unsigned long type)
1851 {
1852   switch (type)
1853     {
1854     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1855     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1856     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1857     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1858     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1859     case DT_HP_PREINIT:         return "HP_PREINIT";
1860     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1861     case DT_HP_NEEDED:          return "HP_NEEDED";
1862     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1863     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1864     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1865     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1866     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1867     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1868     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1869     case DT_HP_FILTERED:        return "HP_FILTERED";
1870     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1871     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1872     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1873     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1874     case DT_PLT:                return "PLT";
1875     case DT_PLT_SIZE:           return "PLT_SIZE";
1876     case DT_DLT:                return "DLT";
1877     case DT_DLT_SIZE:           return "DLT_SIZE";
1878     default:
1879       return NULL;
1880     }
1881 }
1882
1883 static const char *
1884 get_ia64_dynamic_type (unsigned long type)
1885 {
1886   switch (type)
1887     {
1888     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1889     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1890     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1891     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1892     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1893     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1894     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1895     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1896     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1897     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1898     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1899     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1900     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1901     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1902     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1903     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1904     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1905     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1906     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1907     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1908     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1909     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1910     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1911     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1912     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1913     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1914     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1915     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1916     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1917     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1918     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1919     default:
1920       return NULL;
1921     }
1922 }
1923
1924 static const char *
1925 get_solaris_section_type (unsigned long type)
1926 {
1927   switch (type)
1928     {
1929     case 0x6fffffee: return "SUNW_ancillary";
1930     case 0x6fffffef: return "SUNW_capchain";
1931     case 0x6ffffff0: return "SUNW_capinfo";
1932     case 0x6ffffff1: return "SUNW_symsort";
1933     case 0x6ffffff2: return "SUNW_tlssort";
1934     case 0x6ffffff3: return "SUNW_LDYNSYM";
1935     case 0x6ffffff4: return "SUNW_dof";
1936     case 0x6ffffff5: return "SUNW_cap";
1937     case 0x6ffffff6: return "SUNW_SIGNATURE";
1938     case 0x6ffffff7: return "SUNW_ANNOTATE";
1939     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1940     case 0x6ffffff9: return "SUNW_DEBUG";
1941     case 0x6ffffffa: return "SUNW_move";
1942     case 0x6ffffffb: return "SUNW_COMDAT";
1943     case 0x6ffffffc: return "SUNW_syminfo";
1944     case 0x6ffffffd: return "SUNW_verdef";
1945     case 0x6ffffffe: return "SUNW_verneed";
1946     case 0x6fffffff: return "SUNW_versym";
1947     case 0x70000000: return "SPARC_GOTDATA";
1948     default: return NULL;
1949     }
1950 }
1951
1952 static const char *
1953 get_alpha_dynamic_type (unsigned long type)
1954 {
1955   switch (type)
1956     {
1957     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1958     default: return NULL;
1959     }
1960 }
1961
1962 static const char *
1963 get_score_dynamic_type (unsigned long type)
1964 {
1965   switch (type)
1966     {
1967     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1968     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1969     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1970     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1971     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1972     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1973     default:                    return NULL;
1974     }
1975 }
1976
1977 static const char *
1978 get_tic6x_dynamic_type (unsigned long type)
1979 {
1980   switch (type)
1981     {
1982     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1983     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1984     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1985     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1986     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1987     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
1988     default:                   return NULL;
1989     }
1990 }
1991
1992 static const char *
1993 get_nios2_dynamic_type (unsigned long type)
1994 {
1995   switch (type)
1996     {
1997     case DT_NIOS2_GP: return "NIOS2_GP";
1998     default:          return NULL;
1999     }
2000 }
2001
2002 static const char *
2003 get_solaris_dynamic_type (unsigned long type)
2004 {
2005   switch (type)
2006     {
2007     case 0x6000000d: return "SUNW_AUXILIARY";
2008     case 0x6000000e: return "SUNW_RTLDINF";
2009     case 0x6000000f: return "SUNW_FILTER";
2010     case 0x60000010: return "SUNW_CAP";
2011     case 0x60000011: return "SUNW_SYMTAB";
2012     case 0x60000012: return "SUNW_SYMSZ";
2013     case 0x60000013: return "SUNW_SORTENT";
2014     case 0x60000014: return "SUNW_SYMSORT";
2015     case 0x60000015: return "SUNW_SYMSORTSZ";
2016     case 0x60000016: return "SUNW_TLSSORT";
2017     case 0x60000017: return "SUNW_TLSSORTSZ";
2018     case 0x60000018: return "SUNW_CAPINFO";
2019     case 0x60000019: return "SUNW_STRPAD";
2020     case 0x6000001a: return "SUNW_CAPCHAIN";
2021     case 0x6000001b: return "SUNW_LDMACH";
2022     case 0x6000001d: return "SUNW_CAPCHAINENT";
2023     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2024     case 0x60000021: return "SUNW_PARENT";
2025     case 0x60000023: return "SUNW_ASLR";
2026     case 0x60000025: return "SUNW_RELAX";
2027     case 0x60000029: return "SUNW_NXHEAP";
2028     case 0x6000002b: return "SUNW_NXSTACK";
2029
2030     case 0x70000001: return "SPARC_REGISTER";
2031     case 0x7ffffffd: return "AUXILIARY";
2032     case 0x7ffffffe: return "USED";
2033     case 0x7fffffff: return "FILTER";
2034
2035     default: return NULL;
2036     }
2037 }
2038
2039 static const char *
2040 get_dynamic_type (unsigned long type)
2041 {
2042   static char buff[64];
2043
2044   switch (type)
2045     {
2046     case DT_NULL:       return "NULL";
2047     case DT_NEEDED:     return "NEEDED";
2048     case DT_PLTRELSZ:   return "PLTRELSZ";
2049     case DT_PLTGOT:     return "PLTGOT";
2050     case DT_HASH:       return "HASH";
2051     case DT_STRTAB:     return "STRTAB";
2052     case DT_SYMTAB:     return "SYMTAB";
2053     case DT_RELA:       return "RELA";
2054     case DT_RELASZ:     return "RELASZ";
2055     case DT_RELAENT:    return "RELAENT";
2056     case DT_STRSZ:      return "STRSZ";
2057     case DT_SYMENT:     return "SYMENT";
2058     case DT_INIT:       return "INIT";
2059     case DT_FINI:       return "FINI";
2060     case DT_SONAME:     return "SONAME";
2061     case DT_RPATH:      return "RPATH";
2062     case DT_SYMBOLIC:   return "SYMBOLIC";
2063     case DT_REL:        return "REL";
2064     case DT_RELSZ:      return "RELSZ";
2065     case DT_RELENT:     return "RELENT";
2066     case DT_PLTREL:     return "PLTREL";
2067     case DT_DEBUG:      return "DEBUG";
2068     case DT_TEXTREL:    return "TEXTREL";
2069     case DT_JMPREL:     return "JMPREL";
2070     case DT_BIND_NOW:   return "BIND_NOW";
2071     case DT_INIT_ARRAY: return "INIT_ARRAY";
2072     case DT_FINI_ARRAY: return "FINI_ARRAY";
2073     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2074     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2075     case DT_RUNPATH:    return "RUNPATH";
2076     case DT_FLAGS:      return "FLAGS";
2077
2078     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2079     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2080     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2081
2082     case DT_CHECKSUM:   return "CHECKSUM";
2083     case DT_PLTPADSZ:   return "PLTPADSZ";
2084     case DT_MOVEENT:    return "MOVEENT";
2085     case DT_MOVESZ:     return "MOVESZ";
2086     case DT_FEATURE:    return "FEATURE";
2087     case DT_POSFLAG_1:  return "POSFLAG_1";
2088     case DT_SYMINSZ:    return "SYMINSZ";
2089     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2090
2091     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2092     case DT_CONFIG:     return "CONFIG";
2093     case DT_DEPAUDIT:   return "DEPAUDIT";
2094     case DT_AUDIT:      return "AUDIT";
2095     case DT_PLTPAD:     return "PLTPAD";
2096     case DT_MOVETAB:    return "MOVETAB";
2097     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2098
2099     case DT_VERSYM:     return "VERSYM";
2100
2101     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2102     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2103     case DT_RELACOUNT:  return "RELACOUNT";
2104     case DT_RELCOUNT:   return "RELCOUNT";
2105     case DT_FLAGS_1:    return "FLAGS_1";
2106     case DT_VERDEF:     return "VERDEF";
2107     case DT_VERDEFNUM:  return "VERDEFNUM";
2108     case DT_VERNEED:    return "VERNEED";
2109     case DT_VERNEEDNUM: return "VERNEEDNUM";
2110
2111     case DT_AUXILIARY:  return "AUXILIARY";
2112     case DT_USED:       return "USED";
2113     case DT_FILTER:     return "FILTER";
2114
2115     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2116     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2117     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2118     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2119     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2120     case DT_GNU_HASH:   return "GNU_HASH";
2121
2122     default:
2123       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2124         {
2125           const char * result;
2126
2127           switch (elf_header.e_machine)
2128             {
2129             case EM_MIPS:
2130             case EM_MIPS_RS3_LE:
2131               result = get_mips_dynamic_type (type);
2132               break;
2133             case EM_SPARCV9:
2134               result = get_sparc64_dynamic_type (type);
2135               break;
2136             case EM_PPC:
2137               result = get_ppc_dynamic_type (type);
2138               break;
2139             case EM_PPC64:
2140               result = get_ppc64_dynamic_type (type);
2141               break;
2142             case EM_IA_64:
2143               result = get_ia64_dynamic_type (type);
2144               break;
2145             case EM_ALPHA:
2146               result = get_alpha_dynamic_type (type);
2147               break;
2148             case EM_SCORE:
2149               result = get_score_dynamic_type (type);
2150               break;
2151             case EM_TI_C6000:
2152               result = get_tic6x_dynamic_type (type);
2153               break;
2154             case EM_ALTERA_NIOS2:
2155               result = get_nios2_dynamic_type (type);
2156               break;
2157             default:
2158               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2159                 result = get_solaris_dynamic_type (type);
2160               else
2161                 result = NULL;
2162               break;
2163             }
2164
2165           if (result != NULL)
2166             return result;
2167
2168           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2169         }
2170       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2171                || (elf_header.e_machine == EM_PARISC
2172                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2173         {
2174           const char * result;
2175
2176           switch (elf_header.e_machine)
2177             {
2178             case EM_PARISC:
2179               result = get_parisc_dynamic_type (type);
2180               break;
2181             case EM_IA_64:
2182               result = get_ia64_dynamic_type (type);
2183               break;
2184             default:
2185               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2186                 result = get_solaris_dynamic_type (type);
2187               else
2188                 result = NULL;
2189               break;
2190             }
2191
2192           if (result != NULL)
2193             return result;
2194
2195           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2196                     type);
2197         }
2198       else
2199         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2200
2201       return buff;
2202     }
2203 }
2204
2205 static char *
2206 get_file_type (unsigned e_type)
2207 {
2208   static char buff[32];
2209
2210   switch (e_type)
2211     {
2212     case ET_NONE: return _("NONE (None)");
2213     case ET_REL:  return _("REL (Relocatable file)");
2214     case ET_EXEC: return _("EXEC (Executable file)");
2215     case ET_DYN:  return _("DYN (Shared object file)");
2216     case ET_CORE: return _("CORE (Core file)");
2217
2218     default:
2219       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2220         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2221       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2222         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2223       else
2224         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2225       return buff;
2226     }
2227 }
2228
2229 static char *
2230 get_machine_name (unsigned e_machine)
2231 {
2232   static char buff[64]; /* XXX */
2233
2234   switch (e_machine)
2235     {
2236       /* Please keep this switch table sorted by increasing EM_ value.  */
2237       /* 0 */
2238     case EM_NONE:               return _("None");
2239     case EM_M32:                return "WE32100";
2240     case EM_SPARC:              return "Sparc";
2241     case EM_386:                return "Intel 80386";
2242     case EM_68K:                return "MC68000";
2243     case EM_88K:                return "MC88000";
2244     case EM_IAMCU:              return "Intel MCU";
2245     case EM_860:                return "Intel 80860";
2246     case EM_MIPS:               return "MIPS R3000";
2247     case EM_S370:               return "IBM System/370";
2248       /* 10 */
2249     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2250     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2251     case EM_PARISC:             return "HPPA";
2252     case EM_VPP550:             return "Fujitsu VPP500";
2253     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2254     case EM_960:                return "Intel 90860";
2255     case EM_PPC:                return "PowerPC";
2256       /* 20 */
2257     case EM_PPC64:              return "PowerPC64";
2258     case EM_S390_OLD:
2259     case EM_S390:               return "IBM S/390";
2260     case EM_SPU:                return "SPU";
2261       /* 30 */
2262     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2263     case EM_FR20:               return "Fujitsu FR20";
2264     case EM_RH32:               return "TRW RH32";
2265     case EM_MCORE:              return "MCORE";
2266       /* 40 */
2267     case EM_ARM:                return "ARM";
2268     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2269     case EM_SH:                 return "Renesas / SuperH SH";
2270     case EM_SPARCV9:            return "Sparc v9";
2271     case EM_TRICORE:            return "Siemens Tricore";
2272     case EM_ARC:                return "ARC";
2273     case EM_H8_300:             return "Renesas H8/300";
2274     case EM_H8_300H:            return "Renesas H8/300H";
2275     case EM_H8S:                return "Renesas H8S";
2276     case EM_H8_500:             return "Renesas H8/500";
2277       /* 50 */
2278     case EM_IA_64:              return "Intel IA-64";
2279     case EM_MIPS_X:             return "Stanford MIPS-X";
2280     case EM_COLDFIRE:           return "Motorola Coldfire";
2281     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2282     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2283     case EM_PCP:                return "Siemens PCP";
2284     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2285     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2286     case EM_STARCORE:           return "Motorola Star*Core processor";
2287     case EM_ME16:               return "Toyota ME16 processor";
2288       /* 60 */
2289     case EM_ST100:              return "STMicroelectronics ST100 processor";
2290     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2291     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2292     case EM_PDSP:               return "Sony DSP processor";
2293     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2294     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2295     case EM_FX66:               return "Siemens FX66 microcontroller";
2296     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2297     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2298     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2299       /* 70 */
2300     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2301     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2302     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2303     case EM_SVX:                return "Silicon Graphics SVx";
2304     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2305     case EM_VAX:                return "Digital VAX";
2306     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2307     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2308     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2309     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2310       /* 80 */
2311     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2312     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2313     case EM_PRISM:              return "Vitesse Prism";
2314     case EM_AVR_OLD:
2315     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2316     case EM_CYGNUS_FR30:
2317     case EM_FR30:               return "Fujitsu FR30";
2318     case EM_CYGNUS_D10V:
2319     case EM_D10V:               return "d10v";
2320     case EM_CYGNUS_D30V:
2321     case EM_D30V:               return "d30v";
2322     case EM_CYGNUS_V850:
2323     case EM_V850:               return "Renesas V850";
2324     case EM_CYGNUS_M32R:
2325     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2326     case EM_CYGNUS_MN10300:
2327     case EM_MN10300:            return "mn10300";
2328       /* 90 */
2329     case EM_CYGNUS_MN10200:
2330     case EM_MN10200:            return "mn10200";
2331     case EM_PJ:                 return "picoJava";
2332     case EM_OR1K:               return "OpenRISC 1000";
2333     case EM_ARC_COMPACT:        return "ARCompact";
2334     case EM_XTENSA_OLD:
2335     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2336     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2337     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2338     case EM_NS32K:              return "National Semiconductor 32000 series";
2339     case EM_TPC:                return "Tenor Network TPC processor";
2340     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2341       /* 100 */
2342     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2343     case EM_IP2K_OLD:
2344     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2345     case EM_MAX:                return "MAX Processor";
2346     case EM_CR:                 return "National Semiconductor CompactRISC";
2347     case EM_F2MC16:             return "Fujitsu F2MC16";
2348     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2349     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2350     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2351     case EM_SEP:                return "Sharp embedded microprocessor";
2352     case EM_ARCA:               return "Arca RISC microprocessor";
2353       /* 110 */
2354     case EM_UNICORE:            return "Unicore";
2355     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2356     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2357     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2358     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2359     case EM_XGATE:              return "Motorola XGATE embedded processor";
2360     case EM_C166:
2361     case EM_XC16X:              return "Infineon Technologies xc16x";
2362     case EM_M16C:               return "Renesas M16C series microprocessors";
2363     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2364     case EM_CE:                 return "Freescale Communication Engine RISC core";
2365       /* 120 */
2366     case EM_M32C:               return "Renesas M32c";
2367       /* 130 */
2368     case EM_TSK3000:            return "Altium TSK3000 core";
2369     case EM_RS08:               return "Freescale RS08 embedded processor";
2370     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2371     case EM_SCORE:              return "SUNPLUS S+Core";
2372     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2373     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2374     case EM_LATTICEMICO32:      return "Lattice Mico32";
2375     case EM_SE_C17:             return "Seiko Epson C17 family";
2376       /* 140 */
2377     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2378     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2379     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2380     case EM_TI_PRU:             return "TI PRU I/O processor";
2381       /* 160 */
2382     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2383     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2384     case EM_R32C:               return "Renesas R32C series microprocessors";
2385     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2386     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2387     case EM_8051:               return "Intel 8051 and variants";
2388     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2389     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2390     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2391     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2392       /* 170 */
2393     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2394     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2395     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2396     case EM_RX:                 return "Renesas RX";
2397     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2398     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2399     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2400     case EM_CR16:
2401     case EM_MICROBLAZE:
2402     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2403     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2404     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2405       /* 180 */
2406     case EM_L1OM:               return "Intel L1OM";
2407     case EM_K1OM:               return "Intel K1OM";
2408     case EM_INTEL182:           return "Intel (reserved)";
2409     case EM_AARCH64:            return "AArch64";
2410     case EM_ARM184:             return "ARM (reserved)";
2411     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2412     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2413     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2414     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2415       /* 190 */
2416     case EM_CUDA:               return "NVIDIA CUDA architecture";
2417     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2418     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2419     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2420     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2421     case EM_ARC_COMPACT2:       return "ARCv2";
2422     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2423     case EM_RL78:               return "Renesas RL78";
2424     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2425     case EM_78K0R:              return "Renesas 78K0R";
2426       /* 200 */
2427     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2428     case EM_BA1:                return "Beyond BA1 CPU architecture";
2429     case EM_BA2:                return "Beyond BA2 CPU architecture";
2430     case EM_XCORE:              return "XMOS xCORE processor family";
2431     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2432       /* 210 */
2433     case EM_KM32:               return "KM211 KM32 32-bit processor";
2434     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2435     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2436     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2437     case EM_KVARC:              return "KM211 KVARC processor";
2438     case EM_CDP:                return "Paneve CDP architecture family";
2439     case EM_COGE:               return "Cognitive Smart Memory Processor";
2440     case EM_COOL:               return "Bluechip Systems CoolEngine";
2441     case EM_NORC:               return "Nanoradio Optimized RISC";
2442     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2443       /* 220 */
2444     case EM_Z80:                return "Zilog Z80";
2445     case EM_VISIUM:             return "CDS VISIUMcore processor";
2446     case EM_FT32:               return "FTDI Chip FT32";
2447     case EM_MOXIE:              return "Moxie";
2448     case EM_AMDGPU:             return "AMD GPU";
2449     case EM_RISCV:              return "RISC-V";
2450     case EM_LANAI:              return "Lanai 32-bit processor";
2451     case EM_BPF:                return "Linux BPF";
2452
2453       /* Large numbers...  */
2454     case EM_MT:                 return "Morpho Techologies MT processor";
2455     case EM_ALPHA:              return "Alpha";
2456     case EM_WEBASSEMBLY:        return "Web Assembly";
2457     case EM_DLX:                return "OpenDLX";
2458     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2459     case EM_IQ2000:             return "Vitesse IQ2000";
2460     case EM_M32C_OLD:
2461     case EM_NIOS32:             return "Altera Nios";
2462     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2463     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2464     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2465
2466     default:
2467       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2468       return buff;
2469     }
2470 }
2471
2472 static void
2473 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2474 {
2475   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2476      other compilers don't a specific architecture type in the e_flags, and
2477      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2478      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2479      architectures.
2480
2481      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2482      but also sets a specific architecture type in the e_flags field.
2483
2484      However, when decoding the flags we don't worry if we see an
2485      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2486      ARCEM architecture type.  */
2487
2488   switch (e_flags & EF_ARC_MACH_MSK)
2489     {
2490       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2491     case EF_ARC_CPU_ARCV2EM:
2492       strcat (buf, ", ARC EM");
2493       break;
2494     case EF_ARC_CPU_ARCV2HS:
2495       strcat (buf, ", ARC HS");
2496       break;
2497
2498       /* We only expect these to occur for EM_ARC_COMPACT.  */
2499     case E_ARC_MACH_ARC600:
2500       strcat (buf, ", ARC600");
2501       break;
2502     case E_ARC_MACH_ARC601:
2503       strcat (buf, ", ARC601");
2504       break;
2505     case E_ARC_MACH_ARC700:
2506       strcat (buf, ", ARC700");
2507       break;
2508
2509       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2510          new ELF with new architecture being read by an old version of
2511          readelf, or (c) An ELF built with non-GNU compiler that does not
2512          set the architecture in the e_flags.  */
2513     default:
2514       if (e_machine == EM_ARC_COMPACT)
2515         strcat (buf, ", Unknown ARCompact");
2516       else
2517         strcat (buf, ", Unknown ARC");
2518       break;
2519     }
2520
2521   switch (e_flags & EF_ARC_OSABI_MSK)
2522     {
2523     case E_ARC_OSABI_ORIG:
2524       strcat (buf, ", (ABI:legacy)");
2525       break;
2526     case E_ARC_OSABI_V2:
2527       strcat (buf, ", (ABI:v2)");
2528       break;
2529       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2530     case E_ARC_OSABI_V3:
2531       strcat (buf, ", v3 no-legacy-syscalls ABI");
2532       break;
2533     case E_ARC_OSABI_V4:
2534       strcat (buf, ", v4 ABI");
2535       break;
2536     default:
2537       strcat (buf, ", unrecognised ARC OSABI flag");
2538       break;
2539     }
2540 }
2541
2542 static void
2543 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2544 {
2545   unsigned eabi;
2546   bfd_boolean unknown = FALSE;
2547
2548   eabi = EF_ARM_EABI_VERSION (e_flags);
2549   e_flags &= ~ EF_ARM_EABIMASK;
2550
2551   /* Handle "generic" ARM flags.  */
2552   if (e_flags & EF_ARM_RELEXEC)
2553     {
2554       strcat (buf, ", relocatable executable");
2555       e_flags &= ~ EF_ARM_RELEXEC;
2556     }
2557
2558   /* Now handle EABI specific flags.  */
2559   switch (eabi)
2560     {
2561     default:
2562       strcat (buf, ", <unrecognized EABI>");
2563       if (e_flags)
2564         unknown = TRUE;
2565       break;
2566
2567     case EF_ARM_EABI_VER1:
2568       strcat (buf, ", Version1 EABI");
2569       while (e_flags)
2570         {
2571           unsigned flag;
2572
2573           /* Process flags one bit at a time.  */
2574           flag = e_flags & - e_flags;
2575           e_flags &= ~ flag;
2576
2577           switch (flag)
2578             {
2579             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2580               strcat (buf, ", sorted symbol tables");
2581               break;
2582
2583             default:
2584               unknown = TRUE;
2585               break;
2586             }
2587         }
2588       break;
2589
2590     case EF_ARM_EABI_VER2:
2591       strcat (buf, ", Version2 EABI");
2592       while (e_flags)
2593         {
2594           unsigned flag;
2595
2596           /* Process flags one bit at a time.  */
2597           flag = e_flags & - e_flags;
2598           e_flags &= ~ flag;
2599
2600           switch (flag)
2601             {
2602             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2603               strcat (buf, ", sorted symbol tables");
2604               break;
2605
2606             case EF_ARM_DYNSYMSUSESEGIDX:
2607               strcat (buf, ", dynamic symbols use segment index");
2608               break;
2609
2610             case EF_ARM_MAPSYMSFIRST:
2611               strcat (buf, ", mapping symbols precede others");
2612               break;
2613
2614             default:
2615               unknown = TRUE;
2616               break;
2617             }
2618         }
2619       break;
2620
2621     case EF_ARM_EABI_VER3:
2622       strcat (buf, ", Version3 EABI");
2623       break;
2624
2625     case EF_ARM_EABI_VER4:
2626       strcat (buf, ", Version4 EABI");
2627       while (e_flags)
2628         {
2629           unsigned flag;
2630
2631           /* Process flags one bit at a time.  */
2632           flag = e_flags & - e_flags;
2633           e_flags &= ~ flag;
2634
2635           switch (flag)
2636             {
2637             case EF_ARM_BE8:
2638               strcat (buf, ", BE8");
2639               break;
2640
2641             case EF_ARM_LE8:
2642               strcat (buf, ", LE8");
2643               break;
2644
2645             default:
2646               unknown = TRUE;
2647               break;
2648             }
2649         }
2650       break;
2651
2652     case EF_ARM_EABI_VER5:
2653       strcat (buf, ", Version5 EABI");
2654       while (e_flags)
2655         {
2656           unsigned flag;
2657
2658           /* Process flags one bit at a time.  */
2659           flag = e_flags & - e_flags;
2660           e_flags &= ~ flag;
2661
2662           switch (flag)
2663             {
2664             case EF_ARM_BE8:
2665               strcat (buf, ", BE8");
2666               break;
2667
2668             case EF_ARM_LE8:
2669               strcat (buf, ", LE8");
2670               break;
2671
2672             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2673               strcat (buf, ", soft-float ABI");
2674               break;
2675
2676             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2677               strcat (buf, ", hard-float ABI");
2678               break;
2679
2680             default:
2681               unknown = TRUE;
2682               break;
2683             }
2684         }
2685       break;
2686
2687     case EF_ARM_EABI_UNKNOWN:
2688       strcat (buf, ", GNU EABI");
2689       while (e_flags)
2690         {
2691           unsigned flag;
2692
2693           /* Process flags one bit at a time.  */
2694           flag = e_flags & - e_flags;
2695           e_flags &= ~ flag;
2696
2697           switch (flag)
2698             {
2699             case EF_ARM_INTERWORK:
2700               strcat (buf, ", interworking enabled");
2701               break;
2702
2703             case EF_ARM_APCS_26:
2704               strcat (buf, ", uses APCS/26");
2705               break;
2706
2707             case EF_ARM_APCS_FLOAT:
2708               strcat (buf, ", uses APCS/float");
2709               break;
2710
2711             case EF_ARM_PIC:
2712               strcat (buf, ", position independent");
2713               break;
2714
2715             case EF_ARM_ALIGN8:
2716               strcat (buf, ", 8 bit structure alignment");
2717               break;
2718
2719             case EF_ARM_NEW_ABI:
2720               strcat (buf, ", uses new ABI");
2721               break;
2722
2723             case EF_ARM_OLD_ABI:
2724               strcat (buf, ", uses old ABI");
2725               break;
2726
2727             case EF_ARM_SOFT_FLOAT:
2728               strcat (buf, ", software FP");
2729               break;
2730
2731             case EF_ARM_VFP_FLOAT:
2732               strcat (buf, ", VFP");
2733               break;
2734
2735             case EF_ARM_MAVERICK_FLOAT:
2736               strcat (buf, ", Maverick FP");
2737               break;
2738
2739             default:
2740               unknown = TRUE;
2741               break;
2742             }
2743         }
2744     }
2745
2746   if (unknown)
2747     strcat (buf,_(", <unknown>"));
2748 }
2749
2750 static void
2751 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2752 {
2753   --size; /* Leave space for null terminator.  */
2754
2755   switch (e_flags & EF_AVR_MACH)
2756     {
2757     case E_AVR_MACH_AVR1:
2758       strncat (buf, ", avr:1", size);
2759       break;
2760     case E_AVR_MACH_AVR2:
2761       strncat (buf, ", avr:2", size);
2762       break;
2763     case E_AVR_MACH_AVR25:
2764       strncat (buf, ", avr:25", size);
2765       break;
2766     case E_AVR_MACH_AVR3:
2767       strncat (buf, ", avr:3", size);
2768       break;
2769     case E_AVR_MACH_AVR31:
2770       strncat (buf, ", avr:31", size);
2771       break;
2772     case E_AVR_MACH_AVR35:
2773       strncat (buf, ", avr:35", size);
2774       break;
2775     case E_AVR_MACH_AVR4:
2776       strncat (buf, ", avr:4", size);
2777       break;
2778     case E_AVR_MACH_AVR5:
2779       strncat (buf, ", avr:5", size);
2780       break;
2781     case E_AVR_MACH_AVR51:
2782       strncat (buf, ", avr:51", size);
2783       break;
2784     case E_AVR_MACH_AVR6:
2785       strncat (buf, ", avr:6", size);
2786       break;
2787     case E_AVR_MACH_AVRTINY:
2788       strncat (buf, ", avr:100", size);
2789       break;
2790     case E_AVR_MACH_XMEGA1:
2791       strncat (buf, ", avr:101", size);
2792       break;
2793     case E_AVR_MACH_XMEGA2:
2794       strncat (buf, ", avr:102", size);
2795       break;
2796     case E_AVR_MACH_XMEGA3:
2797       strncat (buf, ", avr:103", size);
2798       break;
2799     case E_AVR_MACH_XMEGA4:
2800       strncat (buf, ", avr:104", size);
2801       break;
2802     case E_AVR_MACH_XMEGA5:
2803       strncat (buf, ", avr:105", size);
2804       break;
2805     case E_AVR_MACH_XMEGA6:
2806       strncat (buf, ", avr:106", size);
2807       break;
2808     case E_AVR_MACH_XMEGA7:
2809       strncat (buf, ", avr:107", size);
2810       break;
2811     default:
2812       strncat (buf, ", avr:<unknown>", size);
2813       break;
2814     }
2815
2816   size -= strlen (buf);
2817   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2818     strncat (buf, ", link-relax", size);
2819 }
2820
2821 static void
2822 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2823 {
2824   unsigned abi;
2825   unsigned arch;
2826   unsigned config;
2827   unsigned version;
2828   bfd_boolean has_fpu = FALSE;
2829   unsigned int r = 0;
2830
2831   static const char *ABI_STRINGS[] =
2832   {
2833     "ABI v0", /* use r5 as return register; only used in N1213HC */
2834     "ABI v1", /* use r0 as return register */
2835     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2836     "ABI v2fp", /* for FPU */
2837     "AABI",
2838     "ABI2 FP+"
2839   };
2840   static const char *VER_STRINGS[] =
2841   {
2842     "Andes ELF V1.3 or older",
2843     "Andes ELF V1.3.1",
2844     "Andes ELF V1.4"
2845   };
2846   static const char *ARCH_STRINGS[] =
2847   {
2848     "",
2849     "Andes Star v1.0",
2850     "Andes Star v2.0",
2851     "Andes Star v3.0",
2852     "Andes Star v3.0m"
2853   };
2854
2855   abi = EF_NDS_ABI & e_flags;
2856   arch = EF_NDS_ARCH & e_flags;
2857   config = EF_NDS_INST & e_flags;
2858   version = EF_NDS32_ELF_VERSION & e_flags;
2859
2860   memset (buf, 0, size);
2861
2862   switch (abi)
2863     {
2864     case E_NDS_ABI_V0:
2865     case E_NDS_ABI_V1:
2866     case E_NDS_ABI_V2:
2867     case E_NDS_ABI_V2FP:
2868     case E_NDS_ABI_AABI:
2869     case E_NDS_ABI_V2FP_PLUS:
2870       /* In case there are holes in the array.  */
2871       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2872       break;
2873
2874     default:
2875       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2876       break;
2877     }
2878
2879   switch (version)
2880     {
2881     case E_NDS32_ELF_VER_1_2:
2882     case E_NDS32_ELF_VER_1_3:
2883     case E_NDS32_ELF_VER_1_4:
2884       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2885       break;
2886
2887     default:
2888       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2889       break;
2890     }
2891
2892   if (E_NDS_ABI_V0 == abi)
2893     {
2894       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2895       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2896       if (arch == E_NDS_ARCH_STAR_V1_0)
2897         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2898       return;
2899     }
2900
2901   switch (arch)
2902     {
2903     case E_NDS_ARCH_STAR_V1_0:
2904     case E_NDS_ARCH_STAR_V2_0:
2905     case E_NDS_ARCH_STAR_V3_0:
2906     case E_NDS_ARCH_STAR_V3_M:
2907       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2908       break;
2909
2910     default:
2911       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2912       /* ARCH version determines how the e_flags are interpreted.
2913          If it is unknown, we cannot proceed.  */
2914       return;
2915     }
2916
2917   /* Newer ABI; Now handle architecture specific flags.  */
2918   if (arch == E_NDS_ARCH_STAR_V1_0)
2919     {
2920       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2921         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2922
2923       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2924         r += snprintf (buf + r, size -r, ", MAC");
2925
2926       if (config & E_NDS32_HAS_DIV_INST)
2927         r += snprintf (buf + r, size -r, ", DIV");
2928
2929       if (config & E_NDS32_HAS_16BIT_INST)
2930         r += snprintf (buf + r, size -r, ", 16b");
2931     }
2932   else
2933     {
2934       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2935         {
2936           if (version <= E_NDS32_ELF_VER_1_3)
2937             r += snprintf (buf + r, size -r, ", [B8]");
2938           else
2939             r += snprintf (buf + r, size -r, ", EX9");
2940         }
2941
2942       if (config & E_NDS32_HAS_MAC_DX_INST)
2943         r += snprintf (buf + r, size -r, ", MAC_DX");
2944
2945       if (config & E_NDS32_HAS_DIV_DX_INST)
2946         r += snprintf (buf + r, size -r, ", DIV_DX");
2947
2948       if (config & E_NDS32_HAS_16BIT_INST)
2949         {
2950           if (version <= E_NDS32_ELF_VER_1_3)
2951             r += snprintf (buf + r, size -r, ", 16b");
2952           else
2953             r += snprintf (buf + r, size -r, ", IFC");
2954         }
2955     }
2956
2957   if (config & E_NDS32_HAS_EXT_INST)
2958     r += snprintf (buf + r, size -r, ", PERF1");
2959
2960   if (config & E_NDS32_HAS_EXT2_INST)
2961     r += snprintf (buf + r, size -r, ", PERF2");
2962
2963   if (config & E_NDS32_HAS_FPU_INST)
2964     {
2965       has_fpu = TRUE;
2966       r += snprintf (buf + r, size -r, ", FPU_SP");
2967     }
2968
2969   if (config & E_NDS32_HAS_FPU_DP_INST)
2970     {
2971       has_fpu = TRUE;
2972       r += snprintf (buf + r, size -r, ", FPU_DP");
2973     }
2974
2975   if (config & E_NDS32_HAS_FPU_MAC_INST)
2976     {
2977       has_fpu = TRUE;
2978       r += snprintf (buf + r, size -r, ", FPU_MAC");
2979     }
2980
2981   if (has_fpu)
2982     {
2983       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2984         {
2985         case E_NDS32_FPU_REG_8SP_4DP:
2986           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2987           break;
2988         case E_NDS32_FPU_REG_16SP_8DP:
2989           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2990           break;
2991         case E_NDS32_FPU_REG_32SP_16DP:
2992           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2993           break;
2994         case E_NDS32_FPU_REG_32SP_32DP:
2995           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2996           break;
2997         }
2998     }
2999
3000   if (config & E_NDS32_HAS_AUDIO_INST)
3001     r += snprintf (buf + r, size -r, ", AUDIO");
3002
3003   if (config & E_NDS32_HAS_STRING_INST)
3004     r += snprintf (buf + r, size -r, ", STR");
3005
3006   if (config & E_NDS32_HAS_REDUCED_REGS)
3007     r += snprintf (buf + r, size -r, ", 16REG");
3008
3009   if (config & E_NDS32_HAS_VIDEO_INST)
3010     {
3011       if (version <= E_NDS32_ELF_VER_1_3)
3012         r += snprintf (buf + r, size -r, ", VIDEO");
3013       else
3014         r += snprintf (buf + r, size -r, ", SATURATION");
3015     }
3016
3017   if (config & E_NDS32_HAS_ENCRIPT_INST)
3018     r += snprintf (buf + r, size -r, ", ENCRP");
3019
3020   if (config & E_NDS32_HAS_L2C_INST)
3021     r += snprintf (buf + r, size -r, ", L2C");
3022 }
3023
3024 static char *
3025 get_machine_flags (unsigned e_flags, unsigned e_machine)
3026 {
3027   static char buf[1024];
3028
3029   buf[0] = '\0';
3030
3031   if (e_flags)
3032     {
3033       switch (e_machine)
3034         {
3035         default:
3036           break;
3037
3038         case EM_ARC_COMPACT2:
3039         case EM_ARC_COMPACT:
3040           decode_ARC_machine_flags (e_flags, e_machine, buf);
3041           break;
3042
3043         case EM_ARM:
3044           decode_ARM_machine_flags (e_flags, buf);
3045           break;
3046
3047         case EM_AVR:
3048           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3049           break;
3050
3051         case EM_BLACKFIN:
3052           if (e_flags & EF_BFIN_PIC)
3053             strcat (buf, ", PIC");
3054
3055           if (e_flags & EF_BFIN_FDPIC)
3056             strcat (buf, ", FDPIC");
3057
3058           if (e_flags & EF_BFIN_CODE_IN_L1)
3059             strcat (buf, ", code in L1");
3060
3061           if (e_flags & EF_BFIN_DATA_IN_L1)
3062             strcat (buf, ", data in L1");
3063
3064           break;
3065
3066         case EM_CYGNUS_FRV:
3067           switch (e_flags & EF_FRV_CPU_MASK)
3068             {
3069             case EF_FRV_CPU_GENERIC:
3070               break;
3071
3072             default:
3073               strcat (buf, ", fr???");
3074               break;
3075
3076             case EF_FRV_CPU_FR300:
3077               strcat (buf, ", fr300");
3078               break;
3079
3080             case EF_FRV_CPU_FR400:
3081               strcat (buf, ", fr400");
3082               break;
3083             case EF_FRV_CPU_FR405:
3084               strcat (buf, ", fr405");
3085               break;
3086
3087             case EF_FRV_CPU_FR450:
3088               strcat (buf, ", fr450");
3089               break;
3090
3091             case EF_FRV_CPU_FR500:
3092               strcat (buf, ", fr500");
3093               break;
3094             case EF_FRV_CPU_FR550:
3095               strcat (buf, ", fr550");
3096               break;
3097
3098             case EF_FRV_CPU_SIMPLE:
3099               strcat (buf, ", simple");
3100               break;
3101             case EF_FRV_CPU_TOMCAT:
3102               strcat (buf, ", tomcat");
3103               break;
3104             }
3105           break;
3106
3107         case EM_68K:
3108           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3109             strcat (buf, ", m68000");
3110           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3111             strcat (buf, ", cpu32");
3112           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3113             strcat (buf, ", fido_a");
3114           else
3115             {
3116               char const * isa = _("unknown");
3117               char const * mac = _("unknown mac");
3118               char const * additional = NULL;
3119
3120               switch (e_flags & EF_M68K_CF_ISA_MASK)
3121                 {
3122                 case EF_M68K_CF_ISA_A_NODIV:
3123                   isa = "A";
3124                   additional = ", nodiv";
3125                   break;
3126                 case EF_M68K_CF_ISA_A:
3127                   isa = "A";
3128                   break;
3129                 case EF_M68K_CF_ISA_A_PLUS:
3130                   isa = "A+";
3131                   break;
3132                 case EF_M68K_CF_ISA_B_NOUSP:
3133                   isa = "B";
3134                   additional = ", nousp";
3135                   break;
3136                 case EF_M68K_CF_ISA_B:
3137                   isa = "B";
3138                   break;
3139                 case EF_M68K_CF_ISA_C:
3140                   isa = "C";
3141                   break;
3142                 case EF_M68K_CF_ISA_C_NODIV:
3143                   isa = "C";
3144                   additional = ", nodiv";
3145                   break;
3146                 }
3147               strcat (buf, ", cf, isa ");
3148               strcat (buf, isa);
3149               if (additional)
3150                 strcat (buf, additional);
3151               if (e_flags & EF_M68K_CF_FLOAT)
3152                 strcat (buf, ", float");
3153               switch (e_flags & EF_M68K_CF_MAC_MASK)
3154                 {
3155                 case 0:
3156                   mac = NULL;
3157                   break;
3158                 case EF_M68K_CF_MAC:
3159                   mac = "mac";
3160                   break;
3161                 case EF_M68K_CF_EMAC:
3162                   mac = "emac";
3163                   break;
3164                 case EF_M68K_CF_EMAC_B:
3165                   mac = "emac_b";
3166                   break;
3167                 }
3168               if (mac)
3169                 {
3170                   strcat (buf, ", ");
3171                   strcat (buf, mac);
3172                 }
3173             }
3174           break;
3175
3176         case EM_CYGNUS_MEP:
3177           switch (e_flags & EF_MEP_CPU_MASK)
3178             {
3179             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3180             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3181             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3182             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3183             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3184             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3185             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3186             }
3187
3188           switch (e_flags & EF_MEP_COP_MASK)
3189             {
3190             case EF_MEP_COP_NONE: break;
3191             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3192             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3193             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3194             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3195             default: strcat (buf, _("<unknown MeP copro type>")); break;
3196             }
3197
3198           if (e_flags & EF_MEP_LIBRARY)
3199             strcat (buf, ", Built for Library");
3200
3201           if (e_flags & EF_MEP_INDEX_MASK)
3202             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3203                      e_flags & EF_MEP_INDEX_MASK);
3204
3205           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3206             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3207                      e_flags & ~ EF_MEP_ALL_FLAGS);
3208           break;
3209
3210         case EM_PPC:
3211           if (e_flags & EF_PPC_EMB)
3212             strcat (buf, ", emb");
3213
3214           if (e_flags & EF_PPC_RELOCATABLE)
3215             strcat (buf, _(", relocatable"));
3216
3217           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3218             strcat (buf, _(", relocatable-lib"));
3219           break;
3220
3221         case EM_PPC64:
3222           if (e_flags & EF_PPC64_ABI)
3223             {
3224               char abi[] = ", abiv0";
3225
3226               abi[6] += e_flags & EF_PPC64_ABI;
3227               strcat (buf, abi);
3228             }
3229           break;
3230
3231         case EM_V800:
3232           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3233             strcat (buf, ", RH850 ABI");
3234
3235           if (e_flags & EF_V800_850E3)
3236             strcat (buf, ", V3 architecture");
3237
3238           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3239             strcat (buf, ", FPU not used");
3240
3241           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3242             strcat (buf, ", regmode: COMMON");
3243
3244           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3245             strcat (buf, ", r4 not used");
3246
3247           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3248             strcat (buf, ", r30 not used");
3249
3250           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3251             strcat (buf, ", r5 not used");
3252
3253           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3254             strcat (buf, ", r2 not used");
3255
3256           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3257             {
3258               switch (e_flags & - e_flags)
3259                 {
3260                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3261                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3262                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3263                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3264                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3265                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3266                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3267                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3268                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3269                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3270                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3271                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3272                 default: break;
3273                 }
3274             }
3275           break;
3276
3277         case EM_V850:
3278         case EM_CYGNUS_V850:
3279           switch (e_flags & EF_V850_ARCH)
3280             {
3281             case E_V850E3V5_ARCH:
3282               strcat (buf, ", v850e3v5");
3283               break;
3284             case E_V850E2V3_ARCH:
3285               strcat (buf, ", v850e2v3");
3286               break;
3287             case E_V850E2_ARCH:
3288               strcat (buf, ", v850e2");
3289               break;
3290             case E_V850E1_ARCH:
3291               strcat (buf, ", v850e1");
3292               break;
3293             case E_V850E_ARCH:
3294               strcat (buf, ", v850e");
3295               break;
3296             case E_V850_ARCH:
3297               strcat (buf, ", v850");
3298               break;
3299             default:
3300               strcat (buf, _(", unknown v850 architecture variant"));
3301               break;
3302             }
3303           break;
3304
3305         case EM_M32R:
3306         case EM_CYGNUS_M32R:
3307           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3308             strcat (buf, ", m32r");
3309           break;
3310
3311         case EM_MIPS:
3312         case EM_MIPS_RS3_LE:
3313           if (e_flags & EF_MIPS_NOREORDER)
3314             strcat (buf, ", noreorder");
3315
3316           if (e_flags & EF_MIPS_PIC)
3317             strcat (buf, ", pic");
3318
3319           if (e_flags & EF_MIPS_CPIC)
3320             strcat (buf, ", cpic");
3321
3322           if (e_flags & EF_MIPS_UCODE)
3323             strcat (buf, ", ugen_reserved");
3324
3325           if (e_flags & EF_MIPS_ABI2)
3326             strcat (buf, ", abi2");
3327
3328           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3329             strcat (buf, ", odk first");
3330
3331           if (e_flags & EF_MIPS_32BITMODE)
3332             strcat (buf, ", 32bitmode");
3333
3334           if (e_flags & EF_MIPS_NAN2008)
3335             strcat (buf, ", nan2008");
3336
3337           if (e_flags & EF_MIPS_FP64)
3338             strcat (buf, ", fp64");
3339
3340           switch ((e_flags & EF_MIPS_MACH))
3341             {
3342             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3343             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3344             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3345             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3346             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3347             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3348             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3349             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3350             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3351             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3352             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3353             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3354             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3355             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3356             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3357             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3358             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3359             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3360             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3361             case 0:
3362             /* We simply ignore the field in this case to avoid confusion:
3363                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3364                extension.  */
3365               break;
3366             default: strcat (buf, _(", unknown CPU")); break;
3367             }
3368
3369           switch ((e_flags & EF_MIPS_ABI))
3370             {
3371             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3372             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3373             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3374             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3375             case 0:
3376             /* We simply ignore the field in this case to avoid confusion:
3377                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3378                This means it is likely to be an o32 file, but not for
3379                sure.  */
3380               break;
3381             default: strcat (buf, _(", unknown ABI")); break;
3382             }
3383
3384           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3385             strcat (buf, ", mdmx");
3386
3387           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3388             strcat (buf, ", mips16");
3389
3390           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3391             strcat (buf, ", micromips");
3392
3393           switch ((e_flags & EF_MIPS_ARCH))
3394             {
3395             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3396             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3397             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3398             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3399             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3400             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3401             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3402             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3403             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3404             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3405             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3406             default: strcat (buf, _(", unknown ISA")); break;
3407             }
3408           break;
3409
3410         case EM_NDS32:
3411           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3412           break;
3413
3414         case EM_RISCV:
3415           if (e_flags & EF_RISCV_RVC)
3416             strcat (buf, ", RVC");
3417
3418           switch (e_flags & EF_RISCV_FLOAT_ABI)
3419             {
3420             case EF_RISCV_FLOAT_ABI_SOFT:
3421               strcat (buf, ", soft-float ABI");
3422               break;
3423
3424             case EF_RISCV_FLOAT_ABI_SINGLE:
3425               strcat (buf, ", single-float ABI");
3426               break;
3427
3428             case EF_RISCV_FLOAT_ABI_DOUBLE:
3429               strcat (buf, ", double-float ABI");
3430               break;
3431
3432             case EF_RISCV_FLOAT_ABI_QUAD:
3433               strcat (buf, ", quad-float ABI");
3434               break;
3435             }
3436           break;
3437
3438         case EM_SH:
3439           switch ((e_flags & EF_SH_MACH_MASK))
3440             {
3441             case EF_SH1: strcat (buf, ", sh1"); break;
3442             case EF_SH2: strcat (buf, ", sh2"); break;
3443             case EF_SH3: strcat (buf, ", sh3"); break;
3444             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3445             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3446             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3447             case EF_SH3E: strcat (buf, ", sh3e"); break;
3448             case EF_SH4: strcat (buf, ", sh4"); break;
3449             case EF_SH5: strcat (buf, ", sh5"); break;
3450             case EF_SH2E: strcat (buf, ", sh2e"); break;
3451             case EF_SH4A: strcat (buf, ", sh4a"); break;
3452             case EF_SH2A: strcat (buf, ", sh2a"); break;
3453             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3454             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3455             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3456             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3457             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3458             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3459             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3460             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3461             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3462             default: strcat (buf, _(", unknown ISA")); break;
3463             }
3464
3465           if (e_flags & EF_SH_PIC)
3466             strcat (buf, ", pic");
3467
3468           if (e_flags & EF_SH_FDPIC)
3469             strcat (buf, ", fdpic");
3470           break;
3471
3472         case EM_OR1K:
3473           if (e_flags & EF_OR1K_NODELAY)
3474             strcat (buf, ", no delay");
3475           break;
3476
3477         case EM_SPARCV9:
3478           if (e_flags & EF_SPARC_32PLUS)
3479             strcat (buf, ", v8+");
3480
3481           if (e_flags & EF_SPARC_SUN_US1)
3482             strcat (buf, ", ultrasparcI");
3483
3484           if (e_flags & EF_SPARC_SUN_US3)
3485             strcat (buf, ", ultrasparcIII");
3486
3487           if (e_flags & EF_SPARC_HAL_R1)
3488             strcat (buf, ", halr1");
3489
3490           if (e_flags & EF_SPARC_LEDATA)
3491             strcat (buf, ", ledata");
3492
3493           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3494             strcat (buf, ", tso");
3495
3496           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3497             strcat (buf, ", pso");
3498
3499           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3500             strcat (buf, ", rmo");
3501           break;
3502
3503         case EM_PARISC:
3504           switch (e_flags & EF_PARISC_ARCH)
3505             {
3506             case EFA_PARISC_1_0:
3507               strcpy (buf, ", PA-RISC 1.0");
3508               break;
3509             case EFA_PARISC_1_1:
3510               strcpy (buf, ", PA-RISC 1.1");
3511               break;
3512             case EFA_PARISC_2_0:
3513               strcpy (buf, ", PA-RISC 2.0");
3514               break;
3515             default:
3516               break;
3517             }
3518           if (e_flags & EF_PARISC_TRAPNIL)
3519             strcat (buf, ", trapnil");
3520           if (e_flags & EF_PARISC_EXT)
3521             strcat (buf, ", ext");
3522           if (e_flags & EF_PARISC_LSB)
3523             strcat (buf, ", lsb");
3524           if (e_flags & EF_PARISC_WIDE)
3525             strcat (buf, ", wide");
3526           if (e_flags & EF_PARISC_NO_KABP)
3527             strcat (buf, ", no kabp");
3528           if (e_flags & EF_PARISC_LAZYSWAP)
3529             strcat (buf, ", lazyswap");
3530           break;
3531
3532         case EM_PJ:
3533         case EM_PJ_OLD:
3534           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3535             strcat (buf, ", new calling convention");
3536
3537           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3538             strcat (buf, ", gnu calling convention");
3539           break;
3540
3541         case EM_IA_64:
3542           if ((e_flags & EF_IA_64_ABI64))
3543             strcat (buf, ", 64-bit");
3544           else
3545             strcat (buf, ", 32-bit");
3546           if ((e_flags & EF_IA_64_REDUCEDFP))
3547             strcat (buf, ", reduced fp model");
3548           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3549             strcat (buf, ", no function descriptors, constant gp");
3550           else if ((e_flags & EF_IA_64_CONS_GP))
3551             strcat (buf, ", constant gp");
3552           if ((e_flags & EF_IA_64_ABSOLUTE))
3553             strcat (buf, ", absolute");
3554           if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3555             {
3556               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3557                 strcat (buf, ", vms_linkages");
3558               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3559                 {
3560                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3561                   break;
3562                 case EF_IA_64_VMS_COMCOD_WARNING:
3563                   strcat (buf, ", warning");
3564                   break;
3565                 case EF_IA_64_VMS_COMCOD_ERROR:
3566                   strcat (buf, ", error");
3567                   break;
3568                 case EF_IA_64_VMS_COMCOD_ABORT:
3569                   strcat (buf, ", abort");
3570                   break;
3571                 default:
3572                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573                         e_flags & EF_IA_64_VMS_COMCOD);
3574                   strcat (buf, ", <unknown>");
3575                 }
3576             }
3577           break;
3578
3579         case EM_VAX:
3580           if ((e_flags & EF_VAX_NONPIC))
3581             strcat (buf, ", non-PIC");
3582           if ((e_flags & EF_VAX_DFLOAT))
3583             strcat (buf, ", D-Float");
3584           if ((e_flags & EF_VAX_GFLOAT))
3585             strcat (buf, ", G-Float");
3586           break;
3587
3588         case EM_VISIUM:
3589           if (e_flags & EF_VISIUM_ARCH_MCM)
3590             strcat (buf, ", mcm");
3591           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3592             strcat (buf, ", mcm24");
3593           if (e_flags & EF_VISIUM_ARCH_GR6)
3594             strcat (buf, ", gr6");
3595           break;
3596
3597         case EM_RL78:
3598           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3599             {
3600             case E_FLAG_RL78_ANY_CPU: break;
3601             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3602             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3603             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3604             }
3605           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3606             strcat (buf, ", 64-bit doubles");
3607           break;
3608
3609         case EM_RX:
3610           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3611             strcat (buf, ", 64-bit doubles");
3612           if (e_flags & E_FLAG_RX_DSP)
3613             strcat (buf, ", dsp");
3614           if (e_flags & E_FLAG_RX_PID)
3615             strcat (buf, ", pid");
3616           if (e_flags & E_FLAG_RX_ABI)
3617             strcat (buf, ", RX ABI");
3618           if (e_flags & E_FLAG_RX_SINSNS_SET)
3619             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3620                     ? ", uses String instructions" : ", bans String instructions");
3621           if (e_flags & E_FLAG_RX_V2)
3622             strcat (buf, ", V2");
3623           break;
3624
3625         case EM_S390:
3626           if (e_flags & EF_S390_HIGH_GPRS)
3627             strcat (buf, ", highgprs");
3628           break;
3629
3630         case EM_TI_C6000:
3631           if ((e_flags & EF_C6000_REL))
3632             strcat (buf, ", relocatable module");
3633           break;
3634
3635         case EM_MSP430:
3636           strcat (buf, _(": architecture variant: "));
3637           switch (e_flags & EF_MSP430_MACH)
3638             {
3639             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3640             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3641             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3642             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3643             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3644             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3645             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3646             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3647             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3648             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3649             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3650             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3651             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3652             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3653             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3654             default:
3655               strcat (buf, _(": unknown")); break;
3656             }
3657
3658           if (e_flags & ~ EF_MSP430_MACH)
3659             strcat (buf, _(": unknown extra flag bits also present"));
3660         }
3661     }
3662
3663   return buf;
3664 }
3665
3666 static const char *
3667 get_osabi_name (unsigned int osabi)
3668 {
3669   static char buff[32];
3670
3671   switch (osabi)
3672     {
3673     case ELFOSABI_NONE:         return "UNIX - System V";
3674     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3675     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3676     case ELFOSABI_GNU:          return "UNIX - GNU";
3677     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3678     case ELFOSABI_AIX:          return "UNIX - AIX";
3679     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3680     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3681     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3682     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3683     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3684     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3685     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3686     case ELFOSABI_AROS:         return "AROS";
3687     case ELFOSABI_FENIXOS:      return "FenixOS";
3688     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3689     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3690     default:
3691       if (osabi >= 64)
3692         switch (elf_header.e_machine)
3693           {
3694           case EM_ARM:
3695             switch (osabi)
3696               {
3697               case ELFOSABI_ARM:        return "ARM";
3698               default:
3699                 break;
3700               }
3701             break;
3702
3703           case EM_MSP430:
3704           case EM_MSP430_OLD:
3705           case EM_VISIUM:
3706             switch (osabi)
3707               {
3708               case ELFOSABI_STANDALONE: return _("Standalone App");
3709               default:
3710                 break;
3711               }
3712             break;
3713
3714           case EM_TI_C6000:
3715             switch (osabi)
3716               {
3717               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3718               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3719               default:
3720                 break;
3721               }
3722             break;
3723
3724           default:
3725             break;
3726           }
3727       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3728       return buff;
3729     }
3730 }
3731
3732 static const char *
3733 get_aarch64_segment_type (unsigned long type)
3734 {
3735   switch (type)
3736     {
3737     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3738     default:                  return NULL;
3739     }
3740 }
3741
3742 static const char *
3743 get_arm_segment_type (unsigned long type)
3744 {
3745   switch (type)
3746     {
3747     case PT_ARM_EXIDX: return "EXIDX";
3748     default:           return NULL;
3749     }
3750 }
3751
3752 static const char *
3753 get_s390_segment_type (unsigned long type)
3754 {
3755   switch (type)
3756     {
3757     case PT_S390_PGSTE: return "S390_PGSTE";
3758     default:            return NULL;
3759     }
3760 }
3761
3762 static const char *
3763 get_mips_segment_type (unsigned long type)
3764 {
3765   switch (type)
3766     {
3767     case PT_MIPS_REGINFO:   return "REGINFO";
3768     case PT_MIPS_RTPROC:    return "RTPROC";
3769     case PT_MIPS_OPTIONS:   return "OPTIONS";
3770     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3771     default:                return NULL;
3772     }
3773 }
3774
3775 static const char *
3776 get_parisc_segment_type (unsigned long type)
3777 {
3778   switch (type)
3779     {
3780     case PT_HP_TLS:             return "HP_TLS";
3781     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3782     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3783     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3784     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3785     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3786     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3787     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3788     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3789     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3790     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3791     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3792     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3793     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3794     case PT_HP_STACK:           return "HP_STACK";
3795     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3796     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3797     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3798     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3799     default:                    return NULL;
3800     }
3801 }
3802
3803 static const char *
3804 get_ia64_segment_type (unsigned long type)
3805 {
3806   switch (type)
3807     {
3808     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3809     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3810     case PT_HP_TLS:             return "HP_TLS";
3811     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3812     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3813     case PT_IA_64_HP_STACK:     return "HP_STACK";
3814     default:                    return NULL;
3815     }
3816 }
3817
3818 static const char *
3819 get_tic6x_segment_type (unsigned long type)
3820 {
3821   switch (type)
3822     {
3823     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3824     default:               return NULL;
3825     }
3826 }
3827
3828 static const char *
3829 get_solaris_segment_type (unsigned long type)
3830 {
3831   switch (type)
3832     {
3833     case 0x6464e550: return "PT_SUNW_UNWIND";
3834     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3835     case 0x6ffffff7: return "PT_LOSUNW";
3836     case 0x6ffffffa: return "PT_SUNWBSS";
3837     case 0x6ffffffb: return "PT_SUNWSTACK";
3838     case 0x6ffffffc: return "PT_SUNWDTRACE";
3839     case 0x6ffffffd: return "PT_SUNWCAP";
3840     case 0x6fffffff: return "PT_HISUNW";
3841     default:         return NULL;
3842     }
3843 }
3844
3845 static const char *
3846 get_segment_type (unsigned long p_type)
3847 {
3848   static char buff[32];
3849
3850   switch (p_type)
3851     {
3852     case PT_NULL:       return "NULL";
3853     case PT_LOAD:       return "LOAD";
3854     case PT_DYNAMIC:    return "DYNAMIC";
3855     case PT_INTERP:     return "INTERP";
3856     case PT_NOTE:       return "NOTE";
3857     case PT_SHLIB:      return "SHLIB";
3858     case PT_PHDR:       return "PHDR";
3859     case PT_TLS:        return "TLS";
3860     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3861     case PT_GNU_STACK:  return "GNU_STACK";
3862     case PT_GNU_RELRO:  return "GNU_RELRO";
3863
3864     default:
3865       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3866         {
3867           sprintf (buff, "GNU_MBIND+%#lx",
3868                    p_type - PT_GNU_MBIND_LO);
3869         }
3870       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3871         {
3872           const char * result;
3873
3874           switch (elf_header.e_machine)
3875             {
3876             case EM_AARCH64:
3877               result = get_aarch64_segment_type (p_type);
3878               break;
3879             case EM_ARM:
3880               result = get_arm_segment_type (p_type);
3881               break;
3882             case EM_MIPS:
3883             case EM_MIPS_RS3_LE:
3884               result = get_mips_segment_type (p_type);
3885               break;
3886             case EM_PARISC:
3887               result = get_parisc_segment_type (p_type);
3888               break;
3889             case EM_IA_64:
3890               result = get_ia64_segment_type (p_type);
3891               break;
3892             case EM_TI_C6000:
3893               result = get_tic6x_segment_type (p_type);
3894               break;
3895             case EM_S390:
3896             case EM_S390_OLD:
3897               result = get_s390_segment_type (p_type);
3898               break;
3899             default:
3900               result = NULL;
3901               break;
3902             }
3903
3904           if (result != NULL)
3905             return result;
3906
3907           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3908         }
3909       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3910         {
3911           const char * result;
3912
3913           switch (elf_header.e_machine)
3914             {
3915             case EM_PARISC:
3916               result = get_parisc_segment_type (p_type);
3917               break;
3918             case EM_IA_64:
3919               result = get_ia64_segment_type (p_type);
3920               break;
3921             default:
3922               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3923                 result = get_solaris_segment_type (p_type);
3924               else
3925                 result = NULL;
3926               break;
3927             }
3928
3929           if (result != NULL)
3930             return result;
3931
3932           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3933         }
3934       else
3935         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3936
3937       return buff;
3938     }
3939 }
3940
3941 static const char *
3942 get_arc_section_type_name (unsigned int sh_type)
3943 {
3944   switch (sh_type)
3945     {
3946     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3947     default:
3948       break;
3949     }
3950   return NULL;
3951 }
3952
3953 static const char *
3954 get_mips_section_type_name (unsigned int sh_type)
3955 {
3956   switch (sh_type)
3957     {
3958     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3959     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3960     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3961     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3962     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3963     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3964     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3965     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3966     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3967     case SHT_MIPS_RELD:          return "MIPS_RELD";
3968     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3969     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3970     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3971     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3972     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3973     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3974     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3975     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3976     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3977     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3978     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3979     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3980     case SHT_MIPS_LINE:          return "MIPS_LINE";
3981     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3982     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3983     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3984     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3985     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3986     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3987     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
3988     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
3989     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
3990     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
3991     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
3992     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
3993     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
3994     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
3995     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
3996     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3997     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
3998     default:
3999       break;
4000     }
4001   return NULL;
4002 }
4003
4004 static const char *
4005 get_parisc_section_type_name (unsigned int sh_type)
4006 {
4007   switch (sh_type)
4008     {
4009     case SHT_PARISC_EXT:        return "PARISC_EXT";
4010     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4011     case SHT_PARISC_DOC:        return "PARISC_DOC";
4012     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4013     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4014     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4015     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4016     default:                    return NULL;
4017     }
4018 }
4019
4020 static const char *
4021 get_ia64_section_type_name (unsigned int sh_type)
4022 {
4023   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4024   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4025     return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
4026
4027   switch (sh_type)
4028     {
4029     case SHT_IA_64_EXT:                return "IA_64_EXT";
4030     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4031     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4032     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4033     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4034     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4035     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4036     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4037     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4038     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4039     default:
4040       break;
4041     }
4042   return NULL;
4043 }
4044
4045 static const char *
4046 get_x86_64_section_type_name (unsigned int sh_type)
4047 {
4048   switch (sh_type)
4049     {
4050     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4051     default:                    return NULL;
4052     }
4053 }
4054
4055 static const char *
4056 get_aarch64_section_type_name (unsigned int sh_type)
4057 {
4058   switch (sh_type)
4059     {
4060     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4061     default:                     return NULL;
4062     }
4063 }
4064
4065 static const char *
4066 get_arm_section_type_name (unsigned int sh_type)
4067 {
4068   switch (sh_type)
4069     {
4070     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4071     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4072     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4073     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4074     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4075     default:                      return NULL;
4076     }
4077 }
4078
4079 static const char *
4080 get_tic6x_section_type_name (unsigned int sh_type)
4081 {
4082   switch (sh_type)
4083     {
4084     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4085     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4086     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4087     case SHT_TI_ICODE:          return "TI_ICODE";
4088     case SHT_TI_XREF:           return "TI_XREF";
4089     case SHT_TI_HANDLER:        return "TI_HANDLER";
4090     case SHT_TI_INITINFO:       return "TI_INITINFO";
4091     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4092     default:                    return NULL;
4093     }
4094 }
4095
4096 static const char *
4097 get_msp430x_section_type_name (unsigned int sh_type)
4098 {
4099   switch (sh_type)
4100     {
4101     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4102     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4103     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4104     default:                      return NULL;
4105     }
4106 }
4107
4108 static const char *
4109 get_v850_section_type_name (unsigned int sh_type)
4110 {
4111   switch (sh_type)
4112     {
4113     case SHT_V850_SCOMMON:  return "V850 Small Common";
4114     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4115     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4116     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4117     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4118     default:                return NULL;
4119     }
4120 }
4121
4122 static const char *
4123 get_section_type_name (unsigned int sh_type)
4124 {
4125   static char buff[32];
4126   const char * result;
4127
4128   switch (sh_type)
4129     {
4130     case SHT_NULL:              return "NULL";
4131     case SHT_PROGBITS:          return "PROGBITS";
4132     case SHT_SYMTAB:            return "SYMTAB";
4133     case SHT_STRTAB:            return "STRTAB";
4134     case SHT_RELA:              return "RELA";
4135     case SHT_HASH:              return "HASH";
4136     case SHT_DYNAMIC:           return "DYNAMIC";
4137     case SHT_NOTE:              return "NOTE";
4138     case SHT_NOBITS:            return "NOBITS";
4139     case SHT_REL:               return "REL";
4140     case SHT_SHLIB:             return "SHLIB";
4141     case SHT_DYNSYM:            return "DYNSYM";
4142     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4143     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4144     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4145     case SHT_GNU_HASH:          return "GNU_HASH";
4146     case SHT_GROUP:             return "GROUP";
4147     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4148     case SHT_GNU_verdef:        return "VERDEF";
4149     case SHT_GNU_verneed:       return "VERNEED";
4150     case SHT_GNU_versym:        return "VERSYM";
4151     case 0x6ffffff0:            return "VERSYM";
4152     case 0x6ffffffc:            return "VERDEF";
4153     case 0x7ffffffd:            return "AUXILIARY";
4154     case 0x7fffffff:            return "FILTER";
4155     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4156
4157     default:
4158       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4159         {
4160           switch (elf_header.e_machine)
4161             {
4162             case EM_ARC:
4163             case EM_ARC_COMPACT:
4164             case EM_ARC_COMPACT2:
4165               result = get_arc_section_type_name (sh_type);
4166               break;
4167             case EM_MIPS:
4168             case EM_MIPS_RS3_LE:
4169               result = get_mips_section_type_name (sh_type);
4170               break;
4171             case EM_PARISC:
4172               result = get_parisc_section_type_name (sh_type);
4173               break;
4174             case EM_IA_64:
4175               result = get_ia64_section_type_name (sh_type);
4176               break;
4177             case EM_X86_64:
4178             case EM_L1OM:
4179             case EM_K1OM:
4180               result = get_x86_64_section_type_name (sh_type);
4181               break;
4182             case EM_AARCH64:
4183               result = get_aarch64_section_type_name (sh_type);
4184               break;
4185             case EM_ARM:
4186               result = get_arm_section_type_name (sh_type);
4187               break;
4188             case EM_TI_C6000:
4189               result = get_tic6x_section_type_name (sh_type);
4190               break;
4191             case EM_MSP430:
4192               result = get_msp430x_section_type_name (sh_type);
4193               break;
4194             case EM_V800:
4195             case EM_V850:
4196             case EM_CYGNUS_V850:
4197               result = get_v850_section_type_name (sh_type);
4198               break;
4199             default:
4200               result = NULL;
4201               break;
4202             }
4203
4204           if (result != NULL)
4205             return result;
4206
4207           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4208         }
4209       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4210         {
4211           switch (elf_header.e_machine)
4212             {
4213             case EM_IA_64:
4214               result = get_ia64_section_type_name (sh_type);
4215               break;
4216             default:
4217               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4218                 result = get_solaris_section_type (sh_type);
4219               else
4220                 {
4221                   switch (sh_type)
4222                     {
4223                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4224                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4225                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4226                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4227                     default:
4228                       result = NULL;
4229                       break;
4230                     }
4231                 }
4232               break;
4233             }
4234
4235           if (result != NULL)
4236             return result;
4237
4238           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4239         }
4240       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4241         {
4242           switch (elf_header.e_machine)
4243             {
4244             case EM_V800:
4245             case EM_V850:
4246             case EM_CYGNUS_V850:
4247               result = get_v850_section_type_name (sh_type);
4248               break;
4249             default:
4250               result = NULL;
4251               break;
4252             }
4253
4254           if (result != NULL)
4255             return result;
4256
4257           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4258         }
4259       else
4260         /* This message is probably going to be displayed in a 15
4261            character wide field, so put the hex value first.  */
4262         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4263
4264       return buff;
4265     }
4266 }
4267
4268 #define OPTION_DEBUG_DUMP       512
4269 #define OPTION_DYN_SYMS         513
4270 #define OPTION_DWARF_DEPTH      514
4271 #define OPTION_DWARF_START      515
4272 #define OPTION_DWARF_CHECK      516
4273
4274 static struct option options[] =
4275 {
4276   {"all",              no_argument, 0, 'a'},
4277   {"file-header",      no_argument, 0, 'h'},
4278   {"program-headers",  no_argument, 0, 'l'},
4279   {"headers",          no_argument, 0, 'e'},
4280   {"histogram",        no_argument, 0, 'I'},
4281   {"segments",         no_argument, 0, 'l'},
4282   {"sections",         no_argument, 0, 'S'},
4283   {"section-headers",  no_argument, 0, 'S'},
4284   {"section-groups",   no_argument, 0, 'g'},
4285   {"section-details",  no_argument, 0, 't'},
4286   {"full-section-name",no_argument, 0, 'N'},
4287   {"symbols",          no_argument, 0, 's'},
4288   {"syms",             no_argument, 0, 's'},
4289   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4290   {"relocs",           no_argument, 0, 'r'},
4291   {"notes",            no_argument, 0, 'n'},
4292   {"dynamic",          no_argument, 0, 'd'},
4293   {"arch-specific",    no_argument, 0, 'A'},
4294   {"version-info",     no_argument, 0, 'V'},
4295   {"use-dynamic",      no_argument, 0, 'D'},
4296   {"unwind",           no_argument, 0, 'u'},
4297   {"archive-index",    no_argument, 0, 'c'},
4298   {"hex-dump",         required_argument, 0, 'x'},
4299   {"relocated-dump",   required_argument, 0, 'R'},
4300   {"string-dump",      required_argument, 0, 'p'},
4301   {"decompress",       no_argument, 0, 'z'},
4302 #ifdef SUPPORT_DISASSEMBLY
4303   {"instruction-dump", required_argument, 0, 'i'},
4304 #endif
4305   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4306
4307   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4308   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4309   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4310
4311   {"version",          no_argument, 0, 'v'},
4312   {"wide",             no_argument, 0, 'W'},
4313   {"help",             no_argument, 0, 'H'},
4314   {0,                  no_argument, 0, 0}
4315 };
4316
4317 static void
4318 usage (FILE * stream)
4319 {
4320   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4321   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4322   fprintf (stream, _(" Options are:\n\
4323   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4324   -h --file-header       Display the ELF file header\n\
4325   -l --program-headers   Display the program headers\n\
4326      --segments          An alias for --program-headers\n\
4327   -S --section-headers   Display the sections' header\n\
4328      --sections          An alias for --section-headers\n\
4329   -g --section-groups    Display the section groups\n\
4330   -t --section-details   Display the section details\n\
4331   -e --headers           Equivalent to: -h -l -S\n\
4332   -s --syms              Display the symbol table\n\
4333      --symbols           An alias for --syms\n\
4334   --dyn-syms             Display the dynamic symbol table\n\
4335   -n --notes             Display the core notes (if present)\n\
4336   -r --relocs            Display the relocations (if present)\n\
4337   -u --unwind            Display the unwind info (if present)\n\
4338   -d --dynamic           Display the dynamic section (if present)\n\
4339   -V --version-info      Display the version sections (if present)\n\
4340   -A --arch-specific     Display architecture specific information (if any)\n\
4341   -c --archive-index     Display the symbol/file index in an archive\n\
4342   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4343   -x --hex-dump=<number|name>\n\
4344                          Dump the contents of section <number|name> as bytes\n\
4345   -p --string-dump=<number|name>\n\
4346                          Dump the contents of section <number|name> as strings\n\
4347   -R --relocated-dump=<number|name>\n\
4348                          Dump the contents of section <number|name> as relocated bytes\n\
4349   -z --decompress        Decompress section before dumping it\n\
4350   -w[lLiaprmfFsoRt] or\n\
4351   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4352                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4353                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4354                =addr,=cu_index]\n\
4355                          Display the contents of DWARF2 debug sections\n"));
4356   fprintf (stream, _("\
4357   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4358   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4359                          or deeper\n"));
4360 #ifdef SUPPORT_DISASSEMBLY
4361   fprintf (stream, _("\
4362   -i --instruction-dump=<number|name>\n\
4363                          Disassemble the contents of section <number|name>\n"));
4364 #endif
4365   fprintf (stream, _("\
4366   -I --histogram         Display histogram of bucket list lengths\n\
4367   -W --wide              Allow output width to exceed 80 characters\n\
4368   @<file>                Read options from <file>\n\
4369   -H --help              Display this information\n\
4370   -v --version           Display the version number of readelf\n"));
4371
4372   if (REPORT_BUGS_TO[0] && stream == stdout)
4373     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4374
4375   exit (stream == stdout ? 0 : 1);
4376 }
4377
4378 /* Record the fact that the user wants the contents of section number
4379    SECTION to be displayed using the method(s) encoded as flags bits
4380    in TYPE.  Note, TYPE can be zero if we are creating the array for
4381    the first time.  */
4382
4383 static void
4384 request_dump_bynumber (unsigned int section, dump_type type)
4385 {
4386   if (section >= num_dump_sects)
4387     {
4388       dump_type * new_dump_sects;
4389
4390       new_dump_sects = (dump_type *) calloc (section + 1,
4391                                              sizeof (* dump_sects));
4392
4393       if (new_dump_sects == NULL)
4394         error (_("Out of memory allocating dump request table.\n"));
4395       else
4396         {
4397           if (dump_sects)
4398             {
4399               /* Copy current flag settings.  */
4400               memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4401
4402               free (dump_sects);
4403             }
4404
4405           dump_sects = new_dump_sects;
4406           num_dump_sects = section + 1;
4407         }
4408     }
4409
4410   if (dump_sects)
4411     dump_sects[section] |= type;
4412
4413   return;
4414 }
4415
4416 /* Request a dump by section name.  */
4417
4418 static void
4419 request_dump_byname (const char * section, dump_type type)
4420 {
4421   struct dump_list_entry * new_request;
4422
4423   new_request = (struct dump_list_entry *)
4424       malloc (sizeof (struct dump_list_entry));
4425   if (!new_request)
4426     error (_("Out of memory allocating dump request table.\n"));
4427
4428   new_request->name = strdup (section);
4429   if (!new_request->name)
4430     error (_("Out of memory allocating dump request table.\n"));
4431
4432   new_request->type = type;
4433
4434   new_request->next = dump_sects_byname;
4435   dump_sects_byname = new_request;
4436 }
4437
4438 static inline void
4439 request_dump (dump_type type)
4440 {
4441   int section;
4442   char * cp;
4443
4444   do_dump++;
4445   section = strtoul (optarg, & cp, 0);
4446
4447   if (! *cp && section >= 0)
4448     request_dump_bynumber (section, type);
4449   else
4450     request_dump_byname (optarg, type);
4451 }
4452
4453
4454 static void
4455 parse_args (int argc, char ** argv)
4456 {
4457   int c;
4458
4459   if (argc < 2)
4460     usage (stderr);
4461
4462   while ((c = getopt_long
4463           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4464     {
4465       switch (c)
4466         {
4467         case 0:
4468           /* Long options.  */
4469           break;
4470         case 'H':
4471           usage (stdout);
4472           break;
4473
4474         case 'a':
4475           do_syms = TRUE;
4476           do_reloc = TRUE;
4477           do_unwind = TRUE;
4478           do_dynamic = TRUE;
4479           do_header = TRUE;
4480           do_sections = TRUE;
4481           do_section_groups = TRUE;
4482           do_segments = TRUE;
4483           do_version = TRUE;
4484           do_histogram = TRUE;
4485           do_arch = TRUE;
4486           do_notes = TRUE;
4487           break;
4488         case 'g':
4489           do_section_groups = TRUE;
4490           break;
4491         case 't':
4492         case 'N':
4493           do_sections = TRUE;
4494           do_section_details = TRUE;
4495           break;
4496         case 'e':
4497           do_header = TRUE;
4498           do_sections = TRUE;
4499           do_segments = TRUE;
4500           break;
4501         case 'A':
4502           do_arch = TRUE;
4503           break;
4504         case 'D':
4505           do_using_dynamic = TRUE;
4506           break;
4507         case 'r':
4508           do_reloc = TRUE;
4509           break;
4510         case 'u':
4511           do_unwind = TRUE;
4512           break;
4513         case 'h':
4514           do_header = TRUE;
4515           break;
4516         case 'l':
4517           do_segments = TRUE;
4518           break;
4519         case 's':
4520           do_syms = TRUE;
4521           break;
4522         case 'S':
4523           do_sections = TRUE;
4524           break;
4525         case 'd':
4526           do_dynamic = TRUE;
4527           break;
4528         case 'I':
4529           do_histogram = TRUE;
4530           break;
4531         case 'n':
4532           do_notes = TRUE;
4533           break;
4534         case 'c':
4535           do_archive_index = TRUE;
4536           break;
4537         case 'x':
4538           request_dump (HEX_DUMP);
4539           break;
4540         case 'p':
4541           request_dump (STRING_DUMP);
4542           break;
4543         case 'R':
4544           request_dump (RELOC_DUMP);
4545           break;
4546         case 'z':
4547           decompress_dumps = TRUE;
4548           break;
4549         case 'w':
4550           do_dump = TRUE;
4551           if (optarg == 0)
4552             {
4553               do_debugging = TRUE;
4554               dwarf_select_sections_all ();
4555             }
4556           else
4557             {
4558               do_debugging = FALSE;
4559               dwarf_select_sections_by_letters (optarg);
4560             }
4561           break;
4562         case OPTION_DEBUG_DUMP:
4563           do_dump = TRUE;
4564           if (optarg == 0)
4565             do_debugging = TRUE;
4566           else
4567             {
4568               do_debugging = FALSE;
4569               dwarf_select_sections_by_names (optarg);
4570             }
4571           break;
4572         case OPTION_DWARF_DEPTH:
4573           {
4574             char *cp;
4575
4576             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4577           }
4578           break;
4579         case OPTION_DWARF_START:
4580           {
4581             char *cp;
4582
4583             dwarf_start_die = strtoul (optarg, & cp, 0);
4584           }
4585           break;
4586         case OPTION_DWARF_CHECK:
4587           dwarf_check = TRUE;
4588           break;
4589         case OPTION_DYN_SYMS:
4590           do_dyn_syms = TRUE;
4591           break;
4592 #ifdef SUPPORT_DISASSEMBLY
4593         case 'i':
4594           request_dump (DISASS_DUMP);
4595           break;
4596 #endif
4597         case 'v':
4598           print_version (program_name);
4599           break;
4600         case 'V':
4601           do_version = TRUE;
4602           break;
4603         case 'W':
4604           do_wide = TRUE;
4605           break;
4606         default:
4607           /* xgettext:c-format */
4608           error (_("Invalid option '-%c'\n"), c);
4609           /* Fall through.  */
4610         case '?':
4611           usage (stderr);
4612         }
4613     }
4614
4615   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4616       && !do_segments && !do_header && !do_dump && !do_version
4617       && !do_histogram && !do_debugging && !do_arch && !do_notes
4618       && !do_section_groups && !do_archive_index
4619       && !do_dyn_syms)
4620     usage (stderr);
4621 }
4622
4623 static const char *
4624 get_elf_class (unsigned int elf_class)
4625 {
4626   static char buff[32];
4627
4628   switch (elf_class)
4629     {
4630     case ELFCLASSNONE: return _("none");
4631     case ELFCLASS32:   return "ELF32";
4632     case ELFCLASS64:   return "ELF64";
4633     default:
4634       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4635       return buff;
4636     }
4637 }
4638
4639 static const char *
4640 get_data_encoding (unsigned int encoding)
4641 {
4642   static char buff[32];
4643
4644   switch (encoding)
4645     {
4646     case ELFDATANONE: return _("none");
4647     case ELFDATA2LSB: return _("2's complement, little endian");
4648     case ELFDATA2MSB: return _("2's complement, big endian");
4649     default:
4650       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4651       return buff;
4652     }
4653 }
4654
4655 /* Decode the data held in 'elf_header'.  */
4656
4657 static bfd_boolean
4658 process_file_header (void)
4659 {
4660   if (   elf_header.e_ident[EI_MAG0] != ELFMAG0
4661       || elf_header.e_ident[EI_MAG1] != ELFMAG1
4662       || elf_header.e_ident[EI_MAG2] != ELFMAG2
4663       || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4664     {
4665       error
4666         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4667       return FALSE;
4668     }
4669
4670   init_dwarf_regnames (elf_header.e_machine);
4671
4672   if (do_header)
4673     {
4674       unsigned i;
4675
4676       printf (_("ELF Header:\n"));
4677       printf (_("  Magic:   "));
4678       for (i = 0; i < EI_NIDENT; i++)
4679         printf ("%2.2x ", elf_header.e_ident[i]);
4680       printf ("\n");
4681       printf (_("  Class:                             %s\n"),
4682               get_elf_class (elf_header.e_ident[EI_CLASS]));
4683       printf (_("  Data:                              %s\n"),
4684               get_data_encoding (elf_header.e_ident[EI_DATA]));
4685       printf (_("  Version:                           %d %s\n"),
4686               elf_header.e_ident[EI_VERSION],
4687               (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4688                ? "(current)"
4689                : (elf_header.e_ident[EI_VERSION] != EV_NONE
4690                   ? _("<unknown: %lx>")
4691                   : "")));
4692       printf (_("  OS/ABI:                            %s\n"),
4693               get_osabi_name (elf_header.e_ident[EI_OSABI]));
4694       printf (_("  ABI Version:                       %d\n"),
4695               elf_header.e_ident[EI_ABIVERSION]);
4696       printf (_("  Type:                              %s\n"),
4697               get_file_type (elf_header.e_type));
4698       printf (_("  Machine:                           %s\n"),
4699               get_machine_name (elf_header.e_machine));
4700       printf (_("  Version:                           0x%lx\n"),
4701               (unsigned long) elf_header.e_version);
4702
4703       printf (_("  Entry point address:               "));
4704       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4705       printf (_("\n  Start of program headers:          "));
4706       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4707       printf (_(" (bytes into file)\n  Start of section headers:          "));
4708       print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4709       printf (_(" (bytes into file)\n"));
4710
4711       printf (_("  Flags:                             0x%lx%s\n"),
4712               (unsigned long) elf_header.e_flags,
4713               get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4714       printf (_("  Size of this header:               %ld (bytes)\n"),
4715               (long) elf_header.e_ehsize);
4716       printf (_("  Size of program headers:           %ld (bytes)\n"),
4717               (long) elf_header.e_phentsize);
4718       printf (_("  Number of program headers:         %ld"),
4719               (long) elf_header.e_phnum);
4720       if (section_headers != NULL
4721           && elf_header.e_phnum == PN_XNUM
4722           && section_headers[0].sh_info != 0)
4723         printf (" (%ld)", (long) section_headers[0].sh_info);
4724       putc ('\n', stdout);
4725       printf (_("  Size of section headers:           %ld (bytes)\n"),
4726               (long) elf_header.e_shentsize);
4727       printf (_("  Number of section headers:         %ld"),
4728               (long) elf_header.e_shnum);
4729       if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4730         printf (" (%ld)", (long) section_headers[0].sh_size);
4731       putc ('\n', stdout);
4732       printf (_("  Section header string table index: %ld"),
4733               (long) elf_header.e_shstrndx);
4734       if (section_headers != NULL
4735           && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4736         printf (" (%u)", section_headers[0].sh_link);
4737       else if (elf_header.e_shstrndx != SHN_UNDEF
4738                && elf_header.e_shstrndx >= elf_header.e_shnum)
4739         printf (_(" <corrupt: out of range>"));
4740       putc ('\n', stdout);
4741     }
4742
4743   if (section_headers != NULL)
4744     {
4745       if (elf_header.e_phnum == PN_XNUM
4746           && section_headers[0].sh_info != 0)
4747         elf_header.e_phnum = section_headers[0].sh_info;
4748       if (elf_header.e_shnum == SHN_UNDEF)
4749         elf_header.e_shnum = section_headers[0].sh_size;
4750       if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4751         elf_header.e_shstrndx = section_headers[0].sh_link;
4752       else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4753         elf_header.e_shstrndx = SHN_UNDEF;
4754       free (section_headers);
4755       section_headers = NULL;
4756     }
4757
4758   return TRUE;
4759 }
4760
4761 static bfd_boolean
4762 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4763 {
4764   Elf32_External_Phdr * phdrs;
4765   Elf32_External_Phdr * external;
4766   Elf_Internal_Phdr *   internal;
4767   unsigned int i;
4768   unsigned int size = elf_header.e_phentsize;
4769   unsigned int num  = elf_header.e_phnum;
4770
4771   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4772   if (size == 0 || num == 0)
4773     return FALSE;
4774   if (size < sizeof * phdrs)
4775     {
4776       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4777       return FALSE;
4778     }
4779   if (size > sizeof * phdrs)
4780     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4781
4782   phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4783                                             size, num, _("program headers"));
4784   if (phdrs == NULL)
4785     return FALSE;
4786
4787   for (i = 0, internal = pheaders, external = phdrs;
4788        i < elf_header.e_phnum;
4789        i++, internal++, external++)
4790     {
4791       internal->p_type   = BYTE_GET (external->p_type);
4792       internal->p_offset = BYTE_GET (external->p_offset);
4793       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4794       internal->p_paddr  = BYTE_GET (external->p_paddr);
4795       internal->p_filesz = BYTE_GET (external->p_filesz);
4796       internal->p_memsz  = BYTE_GET (external->p_memsz);
4797       internal->p_flags  = BYTE_GET (external->p_flags);
4798       internal->p_align  = BYTE_GET (external->p_align);
4799     }
4800
4801   free (phdrs);
4802   return TRUE;
4803 }
4804
4805 static bfd_boolean
4806 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4807 {
4808   Elf64_External_Phdr * phdrs;
4809   Elf64_External_Phdr * external;
4810   Elf_Internal_Phdr *   internal;
4811   unsigned int i;
4812   unsigned int size = elf_header.e_phentsize;
4813   unsigned int num  = elf_header.e_phnum;
4814
4815   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4816   if (size == 0 || num == 0)
4817     return FALSE;
4818   if (size < sizeof * phdrs)
4819     {
4820       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4821       return FALSE;
4822     }
4823   if (size > sizeof * phdrs)
4824     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4825
4826   phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4827                                             size, num, _("program headers"));
4828   if (!phdrs)
4829     return FALSE;
4830
4831   for (i = 0, internal = pheaders, external = phdrs;
4832        i < elf_header.e_phnum;
4833        i++, internal++, external++)
4834     {
4835       internal->p_type   = BYTE_GET (external->p_type);
4836       internal->p_flags  = BYTE_GET (external->p_flags);
4837       internal->p_offset = BYTE_GET (external->p_offset);
4838       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4839       internal->p_paddr  = BYTE_GET (external->p_paddr);
4840       internal->p_filesz = BYTE_GET (external->p_filesz);
4841       internal->p_memsz  = BYTE_GET (external->p_memsz);
4842       internal->p_align  = BYTE_GET (external->p_align);
4843     }
4844
4845   free (phdrs);
4846   return TRUE;
4847 }
4848
4849 /* Returns TRUE if the program headers were read into `program_headers'.  */
4850
4851 static bfd_boolean
4852 get_program_headers (FILE * file)
4853 {
4854   Elf_Internal_Phdr * phdrs;
4855
4856   /* Check cache of prior read.  */
4857   if (program_headers != NULL)
4858     return TRUE;
4859
4860   /* Be kind to memory checkers by looking for
4861      e_phnum values which we know must be invalid.  */
4862   if (elf_header.e_phnum
4863       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4864       >= current_file_size)
4865     {
4866       error (_("Too many program headers - %#x - the file is not that big\n"),
4867              elf_header.e_phnum);
4868       return FALSE;
4869     }
4870
4871   phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4872                                          sizeof (Elf_Internal_Phdr));
4873   if (phdrs == NULL)
4874     {
4875       error (_("Out of memory reading %u program headers\n"),
4876              elf_header.e_phnum);
4877       return FALSE;
4878     }
4879
4880   if (is_32bit_elf
4881       ? get_32bit_program_headers (file, phdrs)
4882       : get_64bit_program_headers (file, phdrs))
4883     {
4884       program_headers = phdrs;
4885       return TRUE;
4886     }
4887
4888   free (phdrs);
4889   return FALSE;
4890 }
4891
4892 /* Returns TRUE if the program headers were loaded.  */
4893
4894 static bfd_boolean
4895 process_program_headers (FILE * file)
4896 {
4897   Elf_Internal_Phdr * segment;
4898   unsigned int i;
4899   Elf_Internal_Phdr * previous_load = NULL;
4900
4901   if (elf_header.e_phnum == 0)
4902     {
4903       /* PR binutils/12467.  */
4904       if (elf_header.e_phoff != 0)
4905         {
4906           warn (_("possibly corrupt ELF header - it has a non-zero program"
4907                   " header offset, but no program headers\n"));
4908           return FALSE;
4909         }
4910       else if (do_segments)
4911         printf (_("\nThere are no program headers in this file.\n"));
4912       return TRUE;
4913     }
4914
4915   if (do_segments && !do_header)
4916     {
4917       printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4918       printf (_("Entry point "));
4919       print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4920       printf (_("\nThere are %d program headers, starting at offset "),
4921               elf_header.e_phnum);
4922       print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4923       printf ("\n");
4924     }
4925
4926   if (! get_program_headers (file))
4927     return TRUE;
4928
4929   if (do_segments)
4930     {
4931       if (elf_header.e_phnum > 1)
4932         printf (_("\nProgram Headers:\n"));
4933       else
4934         printf (_("\nProgram Headers:\n"));
4935
4936       if (is_32bit_elf)
4937         printf
4938           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4939       else if (do_wide)
4940         printf
4941           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4942       else
4943         {
4944           printf
4945             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4946           printf
4947             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4948         }
4949     }
4950
4951   dynamic_addr = 0;
4952   dynamic_size = 0;
4953
4954   for (i = 0, segment = program_headers;
4955        i < elf_header.e_phnum;
4956        i++, segment++)
4957     {
4958       if (do_segments)
4959         {
4960           printf ("  %-14.14s ", get_segment_type (segment->p_type));
4961
4962           if (is_32bit_elf)
4963             {
4964               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4965               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4966               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4967               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4968               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4969               printf ("%c%c%c ",
4970                       (segment->p_flags & PF_R ? 'R' : ' '),
4971                       (segment->p_flags & PF_W ? 'W' : ' '),
4972                       (segment->p_flags & PF_X ? 'E' : ' '));
4973               printf ("%#lx", (unsigned long) segment->p_align);
4974             }
4975           else if (do_wide)
4976             {
4977               if ((unsigned long) segment->p_offset == segment->p_offset)
4978                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4979               else
4980                 {
4981                   print_vma (segment->p_offset, FULL_HEX);
4982                   putchar (' ');
4983                 }
4984
4985               print_vma (segment->p_vaddr, FULL_HEX);
4986               putchar (' ');
4987               print_vma (segment->p_paddr, FULL_HEX);
4988               putchar (' ');
4989
4990               if ((unsigned long) segment->p_filesz == segment->p_filesz)
4991                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4992               else
4993                 {
4994                   print_vma (segment->p_filesz, FULL_HEX);
4995                   putchar (' ');
4996                 }
4997
4998               if ((unsigned long) segment->p_memsz == segment->p_memsz)
4999                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5000               else
5001                 {
5002                   print_vma (segment->p_memsz, FULL_HEX);
5003                 }
5004
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
5010               if ((unsigned long) segment->p_align == segment->p_align)
5011                 printf ("%#lx", (unsigned long) segment->p_align);
5012               else
5013                 {
5014                   print_vma (segment->p_align, PREFIX_HEX);
5015                 }
5016             }
5017           else
5018             {
5019               print_vma (segment->p_offset, FULL_HEX);
5020               putchar (' ');
5021               print_vma (segment->p_vaddr, FULL_HEX);
5022               putchar (' ');
5023               print_vma (segment->p_paddr, FULL_HEX);
5024               printf ("\n                 ");
5025               print_vma (segment->p_filesz, FULL_HEX);
5026               putchar (' ');
5027               print_vma (segment->p_memsz, FULL_HEX);
5028               printf ("  %c%c%c    ",
5029                       (segment->p_flags & PF_R ? 'R' : ' '),
5030                       (segment->p_flags & PF_W ? 'W' : ' '),
5031                       (segment->p_flags & PF_X ? 'E' : ' '));
5032               print_vma (segment->p_align, PREFIX_HEX);
5033             }
5034
5035           putc ('\n', stdout);
5036         }
5037
5038       switch (segment->p_type)
5039         {
5040         case PT_LOAD:
5041 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5042          required by the ELF standard, several programs, including the Linux
5043          kernel, make use of non-ordered segments.  */
5044           if (previous_load
5045               && previous_load->p_vaddr > segment->p_vaddr)
5046             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5047 #endif
5048           if (segment->p_memsz < segment->p_filesz)
5049             error (_("the segment's file size is larger than its memory size\n"));
5050           previous_load = segment;
5051           break;
5052
5053         case PT_PHDR:
5054           /* PR 20815 - Verify that the program header is loaded into memory.  */
5055           if (i > 0 && previous_load != NULL)
5056             error (_("the PHDR segment must occur before any LOAD segment\n"));
5057           if (elf_header.e_machine != EM_PARISC)
5058             {
5059               unsigned int j;
5060
5061               for (j = 1; j < elf_header.e_phnum; j++)
5062                 if (program_headers[j].p_vaddr <= segment->p_vaddr
5063                     && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5064                     >= (segment->p_vaddr + segment->p_filesz))
5065                   break;
5066               if (j == elf_header.e_phnum)
5067                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5068             }
5069           break;
5070
5071         case PT_DYNAMIC:
5072           if (dynamic_addr)
5073             error (_("more than one dynamic segment\n"));
5074
5075           /* By default, assume that the .dynamic section is the first
5076              section in the DYNAMIC segment.  */
5077           dynamic_addr = segment->p_offset;
5078           dynamic_size = segment->p_filesz;
5079
5080           /* Try to locate the .dynamic section. If there is
5081              a section header table, we can easily locate it.  */
5082           if (section_headers != NULL)
5083             {
5084               Elf_Internal_Shdr * sec;
5085
5086               sec = find_section (".dynamic");
5087               if (sec == NULL || sec->sh_size == 0)
5088                 {
5089                   /* A corresponding .dynamic section is expected, but on
5090                      IA-64/OpenVMS it is OK for it to be missing.  */
5091                   if (!is_ia64_vms ())
5092                     error (_("no .dynamic section in the dynamic segment\n"));
5093                   break;
5094                 }
5095
5096               if (sec->sh_type == SHT_NOBITS)
5097                 {
5098                   dynamic_size = 0;
5099                   break;
5100                 }
5101
5102               dynamic_addr = sec->sh_offset;
5103               dynamic_size = sec->sh_size;
5104
5105               if (dynamic_addr < segment->p_offset
5106                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5107                 warn (_("the .dynamic section is not contained"
5108                         " within the dynamic segment\n"));
5109               else if (dynamic_addr > segment->p_offset)
5110                 warn (_("the .dynamic section is not the first section"
5111                         " in the dynamic segment.\n"));
5112             }
5113
5114           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5115              segment.  Check this after matching against the section headers
5116              so we don't warn on debuginfo file (which have NOBITS .dynamic
5117              sections).  */
5118           if (dynamic_addr + dynamic_size >= current_file_size)
5119             {
5120               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121               dynamic_addr = dynamic_size = 0;
5122             }
5123           break;
5124
5125         case PT_INTERP:
5126           if (fseek (file, archive_file_offset + (long) segment->p_offset,
5127                      SEEK_SET))
5128             error (_("Unable to find program interpreter name\n"));
5129           else
5130             {
5131               char fmt [32];
5132               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5133
5134               if (ret >= (int) sizeof (fmt) || ret < 0)
5135                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5136
5137               program_interpreter[0] = 0;
5138               if (fscanf (file, fmt, program_interpreter) <= 0)
5139                 error (_("Unable to read program interpreter name\n"));
5140
5141               if (do_segments)
5142                 printf (_("      [Requesting program interpreter: %s]\n"),
5143                     program_interpreter);
5144             }
5145           break;
5146         }
5147     }
5148
5149   if (do_segments && section_headers != NULL && string_table != NULL)
5150     {
5151       printf (_("\n Section to Segment mapping:\n"));
5152       printf (_("  Segment Sections...\n"));
5153
5154       for (i = 0; i < elf_header.e_phnum; i++)
5155         {
5156           unsigned int j;
5157           Elf_Internal_Shdr * section;
5158
5159           segment = program_headers + i;
5160           section = section_headers + 1;
5161
5162           printf ("   %2.2d     ", i);
5163
5164           for (j = 1; j < elf_header.e_shnum; j++, section++)
5165             {
5166               if (!ELF_TBSS_SPECIAL (section, segment)
5167                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5168                 printf ("%s ", printable_section_name (section));
5169             }
5170
5171           putc ('\n',stdout);
5172         }
5173     }
5174
5175   return TRUE;
5176 }
5177
5178
5179 /* Find the file offset corresponding to VMA by using the program headers.  */
5180
5181 static long
5182 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5183 {
5184   Elf_Internal_Phdr * seg;
5185
5186   if (! get_program_headers (file))
5187     {
5188       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5189       return (long) vma;
5190     }
5191
5192   for (seg = program_headers;
5193        seg < program_headers + elf_header.e_phnum;
5194        ++seg)
5195     {
5196       if (seg->p_type != PT_LOAD)
5197         continue;
5198
5199       if (vma >= (seg->p_vaddr & -seg->p_align)
5200           && vma + size <= seg->p_vaddr + seg->p_filesz)
5201         return vma - seg->p_vaddr + seg->p_offset;
5202     }
5203
5204   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205         (unsigned long) vma);
5206   return (long) vma;
5207 }
5208
5209
5210 /* Allocate memory and load the sections headers into the global pointer
5211    SECTION_HEADERS.  If PROBE is true, this is just a probe and we do not
5212    generate any error messages if the load fails.  */
5213
5214 static bfd_boolean
5215 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5216 {
5217   Elf32_External_Shdr * shdrs;
5218   Elf_Internal_Shdr *   internal;
5219   unsigned int i;
5220   unsigned int size = elf_header.e_shentsize;
5221   unsigned int num = probe ? 1 : elf_header.e_shnum;
5222
5223   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5224   if (size == 0 || num == 0)
5225     return FALSE;
5226   if (size < sizeof * shdrs)
5227     {
5228       if (! probe)
5229         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5230       return FALSE;
5231     }
5232   if (!probe && size > sizeof * shdrs)
5233     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5234
5235   shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5236                                             size, num,
5237                                             probe ? NULL : _("section headers"));
5238   if (shdrs == NULL)
5239     return FALSE;
5240
5241   if (section_headers != NULL)
5242     free (section_headers);
5243   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5244                                                    sizeof (Elf_Internal_Shdr));
5245   if (section_headers == NULL)
5246     {
5247       if (!probe)
5248         error (_("Out of memory reading %u section headers\n"), num);
5249       return FALSE;
5250     }
5251
5252   for (i = 0, internal = section_headers;
5253        i < num;
5254        i++, internal++)
5255     {
5256       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5257       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5258       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5259       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5260       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5261       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5262       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5263       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5264       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5265       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5266       if (!probe && internal->sh_link > num)
5267         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5268       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5269         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5270     }
5271
5272   free (shdrs);
5273   return TRUE;
5274 }
5275
5276 static bfd_boolean
5277 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5278 {
5279   Elf64_External_Shdr * shdrs;
5280   Elf_Internal_Shdr *   internal;
5281   unsigned int i;
5282   unsigned int size = elf_header.e_shentsize;
5283   unsigned int num = probe ? 1 : elf_header.e_shnum;
5284
5285   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5286   if (size == 0 || num == 0)
5287     return FALSE;
5288   if (size < sizeof * shdrs)
5289     {
5290       if (! probe)
5291         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5292       return FALSE;
5293     }
5294   if (! probe && size > sizeof * shdrs)
5295     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5296
5297   shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5298                                             size, num,
5299                                             probe ? NULL : _("section headers"));
5300   if (shdrs == NULL)
5301     return FALSE;
5302
5303   if (section_headers != NULL)
5304     free (section_headers);
5305   section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5306                                                    sizeof (Elf_Internal_Shdr));
5307   if (section_headers == NULL)
5308     {
5309       if (! probe)
5310         error (_("Out of memory reading %u section headers\n"), num);
5311       return FALSE;
5312     }
5313
5314   for (i = 0, internal = section_headers;
5315        i < num;
5316        i++, internal++)
5317     {
5318       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5319       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5320       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5321       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5322       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5323       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5324       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5325       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5326       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5327       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5328       if (!probe && internal->sh_link > num)
5329         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5330       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5331         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5332     }
5333
5334   free (shdrs);
5335   return TRUE;
5336 }
5337
5338 static Elf_Internal_Sym *
5339 get_32bit_elf_symbols (FILE * file,
5340                        Elf_Internal_Shdr * section,
5341                        unsigned long * num_syms_return)
5342 {
5343   unsigned long number = 0;
5344   Elf32_External_Sym * esyms = NULL;
5345   Elf_External_Sym_Shndx * shndx = NULL;
5346   Elf_Internal_Sym * isyms = NULL;
5347   Elf_Internal_Sym * psym;
5348   unsigned int j;
5349
5350   if (section->sh_size == 0)
5351     {
5352       if (num_syms_return != NULL)
5353         * num_syms_return = 0;
5354       return NULL;
5355     }
5356
5357   /* Run some sanity checks first.  */
5358   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5359     {
5360       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361              printable_section_name (section), (unsigned long) section->sh_entsize);
5362       goto exit_point;
5363     }
5364
5365   if (section->sh_size > current_file_size)
5366     {
5367       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368              printable_section_name (section), (unsigned long) section->sh_size);
5369       goto exit_point;
5370     }
5371
5372   number = section->sh_size / section->sh_entsize;
5373
5374   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5375     {
5376       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5377              (unsigned long) section->sh_size,
5378              printable_section_name (section),
5379              (unsigned long) section->sh_entsize);
5380       goto exit_point;
5381     }
5382
5383   esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5384                                            section->sh_size, _("symbols"));
5385   if (esyms == NULL)
5386     goto exit_point;
5387
5388   {
5389     elf_section_list * entry;
5390
5391     shndx = NULL;
5392     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5393       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5394         {
5395           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5396                                                        entry->hdr->sh_offset,
5397                                                        1, entry->hdr->sh_size,
5398                                                        _("symbol table section indicies"));
5399           if (shndx == NULL)
5400             goto exit_point;
5401           /* PR17531: file: heap-buffer-overflow */
5402           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5403             {
5404               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5405                      printable_section_name (entry->hdr),
5406                      (unsigned long) entry->hdr->sh_size,
5407                      (unsigned long) section->sh_size);
5408               goto exit_point;
5409             }
5410         }
5411   }
5412
5413   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5414
5415   if (isyms == NULL)
5416     {
5417       error (_("Out of memory reading %lu symbols\n"),
5418              (unsigned long) number);
5419       goto exit_point;
5420     }
5421
5422   for (j = 0, psym = isyms; j < number; j++, psym++)
5423     {
5424       psym->st_name  = BYTE_GET (esyms[j].st_name);
5425       psym->st_value = BYTE_GET (esyms[j].st_value);
5426       psym->st_size  = BYTE_GET (esyms[j].st_size);
5427       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5428       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5429         psym->st_shndx
5430           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5431       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5432         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5433       psym->st_info  = BYTE_GET (esyms[j].st_info);
5434       psym->st_other = BYTE_GET (esyms[j].st_other);
5435     }
5436
5437  exit_point:
5438   if (shndx != NULL)
5439     free (shndx);
5440   if (esyms != NULL)
5441     free (esyms);
5442
5443   if (num_syms_return != NULL)
5444     * num_syms_return = isyms == NULL ? 0 : number;
5445
5446   return isyms;
5447 }
5448
5449 static Elf_Internal_Sym *
5450 get_64bit_elf_symbols (FILE * file,
5451                        Elf_Internal_Shdr * section,
5452                        unsigned long * num_syms_return)
5453 {
5454   unsigned long number = 0;
5455   Elf64_External_Sym * esyms = NULL;
5456   Elf_External_Sym_Shndx * shndx = NULL;
5457   Elf_Internal_Sym * isyms = NULL;
5458   Elf_Internal_Sym * psym;
5459   unsigned int j;
5460
5461   if (section->sh_size == 0)
5462     {
5463       if (num_syms_return != NULL)
5464         * num_syms_return = 0;
5465       return NULL;
5466     }
5467
5468   /* Run some sanity checks first.  */
5469   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5470     {
5471       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472              printable_section_name (section),
5473              (unsigned long) section->sh_entsize);
5474       goto exit_point;
5475     }
5476
5477   if (section->sh_size > current_file_size)
5478     {
5479       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480              printable_section_name (section),
5481              (unsigned long) section->sh_size);
5482       goto exit_point;
5483     }
5484
5485   number = section->sh_size / section->sh_entsize;
5486
5487   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5488     {
5489       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490              (unsigned long) section->sh_size,
5491              printable_section_name (section),
5492              (unsigned long) section->sh_entsize);
5493       goto exit_point;
5494     }
5495
5496   esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5497                                            section->sh_size, _("symbols"));
5498   if (!esyms)
5499     goto exit_point;
5500
5501   {
5502     elf_section_list * entry;
5503
5504     shndx = NULL;
5505     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5506       if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5507         {
5508           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5509                                                        entry->hdr->sh_offset,
5510                                                        1, entry->hdr->sh_size,
5511                                                        _("symbol table section indicies"));
5512           if (shndx == NULL)
5513             goto exit_point;
5514           /* PR17531: file: heap-buffer-overflow */
5515           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5516             {
5517               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5518                      printable_section_name (entry->hdr),
5519                      (unsigned long) entry->hdr->sh_size,
5520                      (unsigned long) section->sh_size);
5521               goto exit_point;
5522             }
5523         }
5524   }
5525
5526   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5527
5528   if (isyms == NULL)
5529     {
5530       error (_("Out of memory reading %lu symbols\n"),
5531              (unsigned long) number);
5532       goto exit_point;
5533     }
5534
5535   for (j = 0, psym = isyms; j < number; j++, psym++)
5536     {
5537       psym->st_name  = BYTE_GET (esyms[j].st_name);
5538       psym->st_info  = BYTE_GET (esyms[j].st_info);
5539       psym->st_other = BYTE_GET (esyms[j].st_other);
5540       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5541
5542       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5543         psym->st_shndx
5544           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5545       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5546         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5547
5548       psym->st_value = BYTE_GET (esyms[j].st_value);
5549       psym->st_size  = BYTE_GET (esyms[j].st_size);
5550     }
5551
5552  exit_point:
5553   if (shndx != NULL)
5554     free (shndx);
5555   if (esyms != NULL)
5556     free (esyms);
5557
5558   if (num_syms_return != NULL)
5559     * num_syms_return = isyms == NULL ? 0 : number;
5560
5561   return isyms;
5562 }
5563
5564 static const char *
5565 get_elf_section_flags (bfd_vma sh_flags)
5566 {
5567   static char buff[1024];
5568   char * p = buff;
5569   unsigned int field_size = is_32bit_elf ? 8 : 16;
5570   signed int sindex;
5571   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5572   bfd_vma os_flags = 0;
5573   bfd_vma proc_flags = 0;
5574   bfd_vma unknown_flags = 0;
5575   static const struct
5576     {
5577       const char * str;
5578       unsigned int len;
5579     }
5580   flags [] =
5581     {
5582       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5583       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5584       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5585       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5586       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5587       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5588       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5589       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5590       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5591       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5592       /* IA-64 specific.  */
5593       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5594       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5595       /* IA-64 OpenVMS specific.  */
5596       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5597       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5598       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5599       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5600       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5601       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5602       /* Generic.  */
5603       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604       /* SPARC specific.  */
5605       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5607       /* ARM specific.  */
5608       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5611       /* GNU specific.  */
5612       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5613       /* VLE specific.  */
5614       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5615     };
5616
5617   if (do_section_details)
5618     {
5619       sprintf (buff, "[%*.*lx]: ",
5620                field_size, field_size, (unsigned long) sh_flags);
5621       p += field_size + 4;
5622     }
5623
5624   while (sh_flags)
5625     {
5626       bfd_vma flag;
5627
5628       flag = sh_flags & - sh_flags;
5629       sh_flags &= ~ flag;
5630
5631       if (do_section_details)
5632         {
5633           switch (flag)
5634             {
5635             case SHF_WRITE:             sindex = 0; break;
5636             case SHF_ALLOC:             sindex = 1; break;
5637             case SHF_EXECINSTR:         sindex = 2; break;
5638             case SHF_MERGE:             sindex = 3; break;
5639             case SHF_STRINGS:           sindex = 4; break;
5640             case SHF_INFO_LINK:         sindex = 5; break;
5641             case SHF_LINK_ORDER:        sindex = 6; break;
5642             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5643             case SHF_GROUP:             sindex = 8; break;
5644             case SHF_TLS:               sindex = 9; break;
5645             case SHF_EXCLUDE:           sindex = 18; break;
5646             case SHF_COMPRESSED:        sindex = 20; break;
5647             case SHF_GNU_MBIND:         sindex = 24; break;
5648
5649             default:
5650               sindex = -1;
5651               switch (elf_header.e_machine)
5652                 {
5653                 case EM_IA_64:
5654                   if (flag == SHF_IA_64_SHORT)
5655                     sindex = 10;
5656                   else if (flag == SHF_IA_64_NORECOV)
5657                     sindex = 11;
5658 #ifdef BFD64
5659                   else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5660                     switch (flag)
5661                       {
5662                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5663                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5664                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5665                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5666                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5667                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5668                       default:                        break;
5669                       }
5670 #endif
5671                   break;
5672
5673                 case EM_386:
5674                 case EM_IAMCU:
5675                 case EM_X86_64:
5676                 case EM_L1OM:
5677                 case EM_K1OM:
5678                 case EM_OLD_SPARCV9:
5679                 case EM_SPARC32PLUS:
5680                 case EM_SPARCV9:
5681                 case EM_SPARC:
5682                   if (flag == SHF_ORDERED)
5683                     sindex = 19;
5684                   break;
5685
5686                 case EM_ARM:
5687                   switch (flag)
5688                     {
5689                     case SHF_ENTRYSECT: sindex = 21; break;
5690                     case SHF_ARM_PURECODE: sindex = 22; break;
5691                     case SHF_COMDEF: sindex = 23; break;
5692                     default: break;
5693                     }
5694                   break;
5695                 case EM_PPC:
5696                   if (flag == SHF_PPC_VLE)
5697                     sindex = 25;
5698                   break;
5699
5700                 default:
5701                   break;
5702                 }
5703             }
5704
5705           if (sindex != -1)
5706             {
5707               if (p != buff + field_size + 4)
5708                 {
5709                   if (size < (10 + 2))
5710                     {
5711                       warn (_("Internal error: not enough buffer room for section flag info"));
5712                       return _("<unknown>");
5713                     }
5714                   size -= 2;
5715                   *p++ = ',';
5716                   *p++ = ' ';
5717                 }
5718
5719               size -= flags [sindex].len;
5720               p = stpcpy (p, flags [sindex].str);
5721             }
5722           else if (flag & SHF_MASKOS)
5723             os_flags |= flag;
5724           else if (flag & SHF_MASKPROC)
5725             proc_flags |= flag;
5726           else
5727             unknown_flags |= flag;
5728         }
5729       else
5730         {
5731           switch (flag)
5732             {
5733             case SHF_WRITE:             *p = 'W'; break;
5734             case SHF_ALLOC:             *p = 'A'; break;
5735             case SHF_EXECINSTR:         *p = 'X'; break;
5736             case SHF_MERGE:             *p = 'M'; break;
5737             case SHF_STRINGS:           *p = 'S'; break;
5738             case SHF_INFO_LINK:         *p = 'I'; break;
5739             case SHF_LINK_ORDER:        *p = 'L'; break;
5740             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5741             case SHF_GROUP:             *p = 'G'; break;
5742             case SHF_TLS:               *p = 'T'; break;
5743             case SHF_EXCLUDE:           *p = 'E'; break;
5744             case SHF_COMPRESSED:        *p = 'C'; break;
5745             case SHF_GNU_MBIND:         *p = 'D'; break;
5746
5747             default:
5748               if ((elf_header.e_machine == EM_X86_64
5749                    || elf_header.e_machine == EM_L1OM
5750                    || elf_header.e_machine == EM_K1OM)
5751                   && flag == SHF_X86_64_LARGE)
5752                 *p = 'l';
5753               else if (elf_header.e_machine == EM_ARM
5754                        && flag == SHF_ARM_PURECODE)
5755                   *p = 'y';
5756               else if (elf_header.e_machine == EM_PPC
5757                        && flag == SHF_PPC_VLE)
5758                   *p = 'v';
5759               else if (flag & SHF_MASKOS)
5760                 {
5761                   *p = 'o';
5762                   sh_flags &= ~ SHF_MASKOS;
5763                 }
5764               else if (flag & SHF_MASKPROC)
5765                 {
5766                   *p = 'p';
5767                   sh_flags &= ~ SHF_MASKPROC;
5768                 }
5769               else
5770                 *p = 'x';
5771               break;
5772             }
5773           p++;
5774         }
5775     }
5776
5777   if (do_section_details)
5778     {
5779       if (os_flags)
5780         {
5781           size -= 5 + field_size;
5782           if (p != buff + field_size + 4)
5783             {
5784               if (size < (2 + 1))
5785                 {
5786                   warn (_("Internal error: not enough buffer room for section flag info"));
5787                   return _("<unknown>");
5788                 }
5789               size -= 2;
5790               *p++ = ',';
5791               *p++ = ' ';
5792             }
5793           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5794                    (unsigned long) os_flags);
5795           p += 5 + field_size;
5796         }
5797       if (proc_flags)
5798         {
5799           size -= 7 + field_size;
5800           if (p != buff + field_size + 4)
5801             {
5802               if (size < (2 + 1))
5803                 {
5804                   warn (_("Internal error: not enough buffer room for section flag info"));
5805                   return _("<unknown>");
5806                 }
5807               size -= 2;
5808               *p++ = ',';
5809               *p++ = ' ';
5810             }
5811           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5812                    (unsigned long) proc_flags);
5813           p += 7 + field_size;
5814         }
5815       if (unknown_flags)
5816         {
5817           size -= 10 + field_size;
5818           if (p != buff + field_size + 4)
5819             {
5820               if (size < (2 + 1))
5821                 {
5822                   warn (_("Internal error: not enough buffer room for section flag info"));
5823                   return _("<unknown>");
5824                 }
5825               size -= 2;
5826               *p++ = ',';
5827               *p++ = ' ';
5828             }
5829           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5830                    (unsigned long) unknown_flags);
5831           p += 10 + field_size;
5832         }
5833     }
5834
5835   *p = '\0';
5836   return buff;
5837 }
5838
5839 static unsigned int
5840 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5841 {
5842   if (is_32bit_elf)
5843     {
5844       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5845
5846       if (size < sizeof (* echdr))
5847         {
5848           error (_("Compressed section is too small even for a compression header\n"));
5849           return 0;
5850         }
5851
5852       chdr->ch_type = BYTE_GET (echdr->ch_type);
5853       chdr->ch_size = BYTE_GET (echdr->ch_size);
5854       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5855       return sizeof (*echdr);
5856     }
5857   else
5858     {
5859       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5860
5861       if (size < sizeof (* echdr))
5862         {
5863           error (_("Compressed section is too small even for a compression header\n"));
5864           return 0;
5865         }
5866
5867       chdr->ch_type = BYTE_GET (echdr->ch_type);
5868       chdr->ch_size = BYTE_GET (echdr->ch_size);
5869       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5870       return sizeof (*echdr);
5871     }
5872 }
5873
5874 static bfd_boolean
5875 process_section_headers (FILE * file)
5876 {
5877   Elf_Internal_Shdr * section;
5878   unsigned int i;
5879
5880   section_headers = NULL;
5881
5882   if (elf_header.e_shnum == 0)
5883     {
5884       /* PR binutils/12467.  */
5885       if (elf_header.e_shoff != 0)
5886         {
5887           warn (_("possibly corrupt ELF file header - it has a non-zero"
5888                   " section header offset, but no section headers\n"));
5889           return FALSE;
5890         }
5891       else if (do_sections)
5892         printf (_("\nThere are no sections in this file.\n"));
5893
5894       return TRUE;
5895     }
5896
5897   if (do_sections && !do_header)
5898     printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5899             elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5900
5901   if (is_32bit_elf)
5902     {
5903       if (! get_32bit_section_headers (file, FALSE))
5904         return FALSE;
5905     }
5906   else
5907     {
5908       if (! get_64bit_section_headers (file, FALSE))
5909         return FALSE;
5910     }
5911
5912   /* Read in the string table, so that we have names to display.  */
5913   if (elf_header.e_shstrndx != SHN_UNDEF
5914        && elf_header.e_shstrndx < elf_header.e_shnum)
5915     {
5916       section = section_headers + elf_header.e_shstrndx;
5917
5918       if (section->sh_size != 0)
5919         {
5920           string_table = (char *) get_data (NULL, file, section->sh_offset,
5921                                             1, section->sh_size,
5922                                             _("string table"));
5923
5924           string_table_length = string_table != NULL ? section->sh_size : 0;
5925         }
5926     }
5927
5928   /* Scan the sections for the dynamic symbol table
5929      and dynamic string table and debug sections.  */
5930   dynamic_symbols = NULL;
5931   dynamic_strings = NULL;
5932   dynamic_syminfo = NULL;
5933   symtab_shndx_list = NULL;
5934
5935   eh_addr_size = is_32bit_elf ? 4 : 8;
5936   switch (elf_header.e_machine)
5937     {
5938     case EM_MIPS:
5939     case EM_MIPS_RS3_LE:
5940       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5941          FDE addresses.  However, the ABI also has a semi-official ILP32
5942          variant for which the normal FDE address size rules apply.
5943
5944          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5945          section, where XX is the size of longs in bits.  Unfortunately,
5946          earlier compilers provided no way of distinguishing ILP32 objects
5947          from LP64 objects, so if there's any doubt, we should assume that
5948          the official LP64 form is being used.  */
5949       if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5950           && find_section (".gcc_compiled_long32") == NULL)
5951         eh_addr_size = 8;
5952       break;
5953
5954     case EM_H8_300:
5955     case EM_H8_300H:
5956       switch (elf_header.e_flags & EF_H8_MACH)
5957         {
5958         case E_H8_MACH_H8300:
5959         case E_H8_MACH_H8300HN:
5960         case E_H8_MACH_H8300SN:
5961         case E_H8_MACH_H8300SXN:
5962           eh_addr_size = 2;
5963           break;
5964         case E_H8_MACH_H8300H:
5965         case E_H8_MACH_H8300S:
5966         case E_H8_MACH_H8300SX:
5967           eh_addr_size = 4;
5968           break;
5969         }
5970       break;
5971
5972     case EM_M32C_OLD:
5973     case EM_M32C:
5974       switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5975         {
5976         case EF_M32C_CPU_M16C:
5977           eh_addr_size = 2;
5978           break;
5979         }
5980       break;
5981     }
5982
5983 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
5984   do                                                                    \
5985     {                                                                   \
5986       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
5987       if (section->sh_entsize != expected_entsize)                      \
5988         {                                                               \
5989           char buf[40];                                                 \
5990           sprintf_vma (buf, section->sh_entsize);                       \
5991           /* Note: coded this way so that there is a single string for  \
5992              translation.  */ \
5993           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5994           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5995                    (unsigned) expected_entsize);                        \
5996           section->sh_entsize = expected_entsize;                       \
5997         }                                                               \
5998     }                                                                   \
5999   while (0)
6000
6001 #define CHECK_ENTSIZE(section, i, type)                                 \
6002   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6003                         sizeof (Elf64_External_##type))
6004
6005   for (i = 0, section = section_headers;
6006        i < elf_header.e_shnum;
6007        i++, section++)
6008     {
6009       char * name = SECTION_NAME (section);
6010
6011       if (section->sh_type == SHT_DYNSYM)
6012         {
6013           if (dynamic_symbols != NULL)
6014             {
6015               error (_("File contains multiple dynamic symbol tables\n"));
6016               continue;
6017             }
6018
6019           CHECK_ENTSIZE (section, i, Sym);
6020           dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
6021         }
6022       else if (section->sh_type == SHT_STRTAB
6023                && streq (name, ".dynstr"))
6024         {
6025           if (dynamic_strings != NULL)
6026             {
6027               error (_("File contains multiple dynamic string tables\n"));
6028               continue;
6029             }
6030
6031           dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
6032                                                1, section->sh_size,
6033                                                _("dynamic strings"));
6034           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6035         }
6036       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6037         {
6038           elf_section_list * entry = xmalloc (sizeof * entry);
6039           entry->hdr = section;
6040           entry->next = symtab_shndx_list;
6041           symtab_shndx_list = entry;
6042         }
6043       else if (section->sh_type == SHT_SYMTAB)
6044         CHECK_ENTSIZE (section, i, Sym);
6045       else if (section->sh_type == SHT_GROUP)
6046         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6047       else if (section->sh_type == SHT_REL)
6048         CHECK_ENTSIZE (section, i, Rel);
6049       else if (section->sh_type == SHT_RELA)
6050         CHECK_ENTSIZE (section, i, Rela);
6051       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6052                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6053                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6054                 || do_debug_str || do_debug_loc || do_debug_ranges
6055                 || do_debug_addr || do_debug_cu_index)
6056                && (const_strneq (name, ".debug_")
6057                    || const_strneq (name, ".zdebug_")))
6058         {
6059           if (name[1] == 'z')
6060             name += sizeof (".zdebug_") - 1;
6061           else
6062             name += sizeof (".debug_") - 1;
6063
6064           if (do_debugging
6065               || (do_debug_info     && const_strneq (name, "info"))
6066               || (do_debug_info     && const_strneq (name, "types"))
6067               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6068               || (do_debug_lines    && strcmp (name, "line") == 0)
6069               || (do_debug_lines    && const_strneq (name, "line."))
6070               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6071               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6072               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6073               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6074               || (do_debug_aranges  && const_strneq (name, "aranges"))
6075               || (do_debug_ranges   && const_strneq (name, "ranges"))
6076               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6077               || (do_debug_frames   && const_strneq (name, "frame"))
6078               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6079               || (do_debug_macinfo  && const_strneq (name, "macro"))
6080               || (do_debug_str      && const_strneq (name, "str"))
6081               || (do_debug_loc      && const_strneq (name, "loc"))
6082               || (do_debug_loc      && const_strneq (name, "loclists"))
6083               || (do_debug_addr     && const_strneq (name, "addr"))
6084               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6085               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6086               )
6087             request_dump_bynumber (i, DEBUG_DUMP);
6088         }
6089       /* Linkonce section to be combined with .debug_info at link time.  */
6090       else if ((do_debugging || do_debug_info)
6091                && const_strneq (name, ".gnu.linkonce.wi."))
6092         request_dump_bynumber (i, DEBUG_DUMP);
6093       else if (do_debug_frames && streq (name, ".eh_frame"))
6094         request_dump_bynumber (i, DEBUG_DUMP);
6095       else if (do_gdb_index && (streq (name, ".gdb_index")
6096                                 || streq (name, ".debug_names")))
6097         request_dump_bynumber (i, DEBUG_DUMP);
6098       /* Trace sections for Itanium VMS.  */
6099       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6100                 || do_trace_aranges)
6101                && const_strneq (name, ".trace_"))
6102         {
6103           name += sizeof (".trace_") - 1;
6104
6105           if (do_debugging
6106               || (do_trace_info     && streq (name, "info"))
6107               || (do_trace_abbrevs  && streq (name, "abbrev"))
6108               || (do_trace_aranges  && streq (name, "aranges"))
6109               )
6110             request_dump_bynumber (i, DEBUG_DUMP);
6111         }
6112     }
6113
6114   if (! do_sections)
6115     return TRUE;
6116
6117   if (elf_header.e_shnum > 1)
6118     printf (_("\nSection Headers:\n"));
6119   else
6120     printf (_("\nSection Header:\n"));
6121
6122   if (is_32bit_elf)
6123     {
6124       if (do_section_details)
6125         {
6126           printf (_("  [Nr] Name\n"));
6127           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6128         }
6129       else
6130         printf
6131           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6132     }
6133   else if (do_wide)
6134     {
6135       if (do_section_details)
6136         {
6137           printf (_("  [Nr] Name\n"));
6138           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6139         }
6140       else
6141         printf
6142           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6143     }
6144   else
6145     {
6146       if (do_section_details)
6147         {
6148           printf (_("  [Nr] Name\n"));
6149           printf (_("       Type              Address          Offset            Link\n"));
6150           printf (_("       Size              EntSize          Info              Align\n"));
6151         }
6152       else
6153         {
6154           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6155           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6156         }
6157     }
6158
6159   if (do_section_details)
6160     printf (_("       Flags\n"));
6161
6162   for (i = 0, section = section_headers;
6163        i < elf_header.e_shnum;
6164        i++, section++)
6165     {
6166       /* Run some sanity checks on the section header.  */
6167
6168       /* Check the sh_link field.  */
6169       switch (section->sh_type)
6170         {
6171         case SHT_SYMTAB_SHNDX:
6172         case SHT_GROUP:
6173         case SHT_HASH:
6174         case SHT_GNU_HASH:
6175         case SHT_GNU_versym:
6176         case SHT_REL:
6177         case SHT_RELA:
6178           if (section->sh_link < 1
6179               || section->sh_link >= elf_header.e_shnum
6180               || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6181                   && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6182             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6183                   i, section->sh_link);
6184           break;
6185
6186         case SHT_DYNAMIC:
6187         case SHT_SYMTAB:
6188         case SHT_DYNSYM:
6189         case SHT_GNU_verneed:
6190         case SHT_GNU_verdef:
6191         case SHT_GNU_LIBLIST:
6192           if (section->sh_link < 1
6193               || section->sh_link >= elf_header.e_shnum
6194               || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6195             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6196                   i, section->sh_link);
6197           break;
6198
6199         case SHT_INIT_ARRAY:
6200         case SHT_FINI_ARRAY:
6201         case SHT_PREINIT_ARRAY:
6202           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6203             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6204                   i, section->sh_link);
6205           break;
6206
6207         default:
6208           /* FIXME: Add support for target specific section types.  */
6209 #if 0     /* Currently we do not check other section types as there are too
6210              many special cases.  Stab sections for example have a type
6211              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6212              section.  */
6213           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6214             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6215                   i, section->sh_link);
6216 #endif
6217           break;
6218         }
6219
6220       /* Check the sh_info field.  */
6221       switch (section->sh_type)
6222         {
6223         case SHT_REL:
6224         case SHT_RELA:
6225           if (section->sh_info < 1
6226               || section->sh_info >= elf_header.e_shnum
6227               || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6228                   && section_headers[section->sh_info].sh_type != SHT_NOBITS
6229                   && section_headers[section->sh_info].sh_type != SHT_NOTE
6230                   && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6231                   /* FIXME: Are other section types valid ?  */
6232                   && section_headers[section->sh_info].sh_type < SHT_LOOS))
6233             {
6234               if (section->sh_info == 0
6235                   && (streq (SECTION_NAME (section), ".rel.dyn")
6236                       || streq (SECTION_NAME (section), ".rela.dyn")))
6237                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6238                    of zero.  The relocations in these sections may apply
6239                    to many different sections.  */
6240                    ;
6241               else
6242                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6243                       i, section->sh_info);
6244             }
6245           break;
6246
6247         case SHT_DYNAMIC:
6248         case SHT_HASH:
6249         case SHT_SYMTAB_SHNDX:
6250         case SHT_INIT_ARRAY:
6251         case SHT_FINI_ARRAY:
6252         case SHT_PREINIT_ARRAY:
6253           if (section->sh_info != 0)
6254             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6255                   i, section->sh_info);
6256           break;
6257
6258         case SHT_GROUP:
6259         case SHT_SYMTAB:
6260         case SHT_DYNSYM:
6261           /* A symbol index - we assume that it is valid.  */
6262           break;
6263
6264         default:
6265           /* FIXME: Add support for target specific section types.  */
6266           if (section->sh_type == SHT_NOBITS)
6267             /* NOBITS section headers with non-zero sh_info fields can be
6268                created when a binary is stripped of everything but its debug
6269                information.  The stripped sections have their headers
6270                preserved but their types set to SHT_NOBITS.  So do not check
6271                this type of section.  */
6272             ;
6273           else if (section->sh_flags & SHF_INFO_LINK)
6274             {
6275               if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6276                 warn (_("[%2u]: Expected link to another section in info field"), i);
6277             }
6278           else if (section->sh_type < SHT_LOOS
6279                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6280                    && section->sh_info != 0)
6281             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6282                   i, section->sh_info);
6283           break;
6284         }
6285
6286       /* Check the sh_size field.  */
6287       if (section->sh_size > current_file_size
6288           && section->sh_type != SHT_NOBITS
6289           && section->sh_type != SHT_NULL
6290           && section->sh_type < SHT_LOOS)
6291         warn (_("Size of section %u is larger than the entire file!\n"), i);
6292
6293       printf ("  [%2u] ", i);
6294       if (do_section_details)
6295         printf ("%s\n      ", printable_section_name (section));
6296       else
6297         print_symbol (-17, SECTION_NAME (section));
6298
6299       printf (do_wide ? " %-15s " : " %-15.15s ",
6300               get_section_type_name (section->sh_type));
6301
6302       if (is_32bit_elf)
6303         {
6304           const char * link_too_big = NULL;
6305
6306           print_vma (section->sh_addr, LONG_HEX);
6307
6308           printf ( " %6.6lx %6.6lx %2.2lx",
6309                    (unsigned long) section->sh_offset,
6310                    (unsigned long) section->sh_size,
6311                    (unsigned long) section->sh_entsize);
6312
6313           if (do_section_details)
6314             fputs ("  ", stdout);
6315           else
6316             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6317
6318           if (section->sh_link >= elf_header.e_shnum)
6319             {
6320               link_too_big = "";
6321               /* The sh_link value is out of range.  Normally this indicates
6322                  an error but it can have special values in Solaris binaries.  */
6323               switch (elf_header.e_machine)
6324                 {
6325                 case EM_386:
6326                 case EM_IAMCU:
6327                 case EM_X86_64:
6328                 case EM_L1OM:
6329                 case EM_K1OM:
6330                 case EM_OLD_SPARCV9:
6331                 case EM_SPARC32PLUS:
6332                 case EM_SPARCV9:
6333                 case EM_SPARC:
6334                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6335                     link_too_big = "BEFORE";
6336                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6337                     link_too_big = "AFTER";
6338                   break;
6339                 default:
6340                   break;
6341                 }
6342             }
6343
6344           if (do_section_details)
6345             {
6346               if (link_too_big != NULL && * link_too_big)
6347                 printf ("<%s> ", link_too_big);
6348               else
6349                 printf ("%2u ", section->sh_link);
6350               printf ("%3u %2lu\n", section->sh_info,
6351                       (unsigned long) section->sh_addralign);
6352             }
6353           else
6354             printf ("%2u %3u %2lu\n",
6355                     section->sh_link,
6356                     section->sh_info,
6357                     (unsigned long) section->sh_addralign);
6358
6359           if (link_too_big && ! * link_too_big)
6360             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6361                   i, section->sh_link);
6362         }
6363       else if (do_wide)
6364         {
6365           print_vma (section->sh_addr, LONG_HEX);
6366
6367           if ((long) section->sh_offset == section->sh_offset)
6368             printf (" %6.6lx", (unsigned long) section->sh_offset);
6369           else
6370             {
6371               putchar (' ');
6372               print_vma (section->sh_offset, LONG_HEX);
6373             }
6374
6375           if ((unsigned long) section->sh_size == section->sh_size)
6376             printf (" %6.6lx", (unsigned long) section->sh_size);
6377           else
6378             {
6379               putchar (' ');
6380               print_vma (section->sh_size, LONG_HEX);
6381             }
6382
6383           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6384             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6385           else
6386             {
6387               putchar (' ');
6388               print_vma (section->sh_entsize, LONG_HEX);
6389             }
6390
6391           if (do_section_details)
6392             fputs ("  ", stdout);
6393           else
6394             printf (" %3s ", get_elf_section_flags (section->sh_flags));
6395
6396           printf ("%2u %3u ", section->sh_link, section->sh_info);
6397
6398           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6399             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6400           else
6401             {
6402               print_vma (section->sh_addralign, DEC);
6403               putchar ('\n');
6404             }
6405         }
6406       else if (do_section_details)
6407         {
6408           printf ("       %-15.15s  ",
6409                   get_section_type_name (section->sh_type));
6410           print_vma (section->sh_addr, LONG_HEX);
6411           if ((long) section->sh_offset == section->sh_offset)
6412             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6413           else
6414             {
6415               printf ("  ");
6416               print_vma (section->sh_offset, LONG_HEX);
6417             }
6418           printf ("  %u\n       ", section->sh_link);
6419           print_vma (section->sh_size, LONG_HEX);
6420           putchar (' ');
6421           print_vma (section->sh_entsize, LONG_HEX);
6422
6423           printf ("  %-16u  %lu\n",
6424                   section->sh_info,
6425                   (unsigned long) section->sh_addralign);
6426         }
6427       else
6428         {
6429           putchar (' ');
6430           print_vma (section->sh_addr, LONG_HEX);
6431           if ((long) section->sh_offset == section->sh_offset)
6432             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6433           else
6434             {
6435               printf ("  ");
6436               print_vma (section->sh_offset, LONG_HEX);
6437             }
6438           printf ("\n       ");
6439           print_vma (section->sh_size, LONG_HEX);
6440           printf ("  ");
6441           print_vma (section->sh_entsize, LONG_HEX);
6442
6443           printf (" %3s ", get_elf_section_flags (section->sh_flags));
6444
6445           printf ("     %2u   %3u     %lu\n",
6446                   section->sh_link,
6447                   section->sh_info,
6448                   (unsigned long) section->sh_addralign);
6449         }
6450
6451       if (do_section_details)
6452         {
6453           printf ("       %s\n", get_elf_section_flags (section->sh_flags));
6454           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6455             {
6456               /* Minimum section size is 12 bytes for 32-bit compression
6457                  header + 12 bytes for compressed data header.  */
6458               unsigned char buf[24];
6459
6460               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6461               if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6462                             sizeof (buf), _("compression header")))
6463                 {
6464                   Elf_Internal_Chdr chdr;
6465
6466                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6467
6468                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6469                     printf ("       ZLIB, ");
6470                   else
6471                     printf (_("       [<unknown>: 0x%x], "),
6472                             chdr.ch_type);
6473                   print_vma (chdr.ch_size, LONG_HEX);
6474                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6475                 }
6476             }
6477         }
6478     }
6479
6480   if (!do_section_details)
6481     {
6482       /* The ordering of the letters shown here matches the ordering of the
6483          corresponding SHF_xxx values, and hence the order in which these
6484          letters will be displayed to the user.  */
6485       printf (_("Key to Flags:\n\
6486   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6487   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6488   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6489       if (elf_header.e_machine == EM_X86_64
6490           || elf_header.e_machine == EM_L1OM
6491           || elf_header.e_machine == EM_K1OM)
6492         printf (_("l (large), "));
6493       else if (elf_header.e_machine == EM_ARM)
6494         printf (_("y (purecode), "));
6495       else if (elf_header.e_machine == EM_PPC)
6496         printf (_("v (VLE), "));
6497       printf ("p (processor specific)\n");
6498     }
6499
6500   return TRUE;
6501 }
6502
6503 static const char *
6504 get_group_flags (unsigned int flags)
6505 {
6506   static char buff[128];
6507
6508   if (flags == 0)
6509     return "";
6510   else if (flags == GRP_COMDAT)
6511     return "COMDAT ";
6512
6513   snprintf (buff, 14, _("[0x%x: "), flags);
6514
6515   flags &= ~ GRP_COMDAT;
6516   if (flags & GRP_MASKOS)
6517     {
6518       strcat (buff, "<OS specific>");
6519       flags &= ~ GRP_MASKOS;
6520     }
6521
6522   if (flags & GRP_MASKPROC)
6523     {
6524       strcat (buff, "<PROC specific>");
6525       flags &= ~ GRP_MASKPROC;
6526     }
6527
6528   if (flags)
6529     strcat (buff, "<unknown>");
6530
6531   strcat (buff, "]");
6532   return buff;
6533 }
6534
6535 static bfd_boolean
6536 process_section_groups (FILE * file)
6537 {
6538   Elf_Internal_Shdr * section;
6539   unsigned int i;
6540   struct group * group;
6541   Elf_Internal_Shdr * symtab_sec;
6542   Elf_Internal_Shdr * strtab_sec;
6543   Elf_Internal_Sym * symtab;
6544   unsigned long num_syms;
6545   char * strtab;
6546   size_t strtab_size;
6547
6548   /* Don't process section groups unless needed.  */
6549   if (!do_unwind && !do_section_groups)
6550     return TRUE;
6551
6552   if (elf_header.e_shnum == 0)
6553     {
6554       if (do_section_groups)
6555         printf (_("\nThere are no sections to group in this file.\n"));
6556
6557       return TRUE;
6558     }
6559
6560   if (section_headers == NULL)
6561     {
6562       error (_("Section headers are not available!\n"));
6563       /* PR 13622: This can happen with a corrupt ELF header.  */
6564       return FALSE;
6565     }
6566
6567   section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6568                                                      sizeof (struct group *));
6569
6570   if (section_headers_groups == NULL)
6571     {
6572       error (_("Out of memory reading %u section group headers\n"),
6573              elf_header.e_shnum);
6574       return FALSE;
6575     }
6576
6577   /* Scan the sections for the group section.  */
6578   group_count = 0;
6579   for (i = 0, section = section_headers;
6580        i < elf_header.e_shnum;
6581        i++, section++)
6582     if (section->sh_type == SHT_GROUP)
6583       group_count++;
6584
6585   if (group_count == 0)
6586     {
6587       if (do_section_groups)
6588         printf (_("\nThere are no section groups in this file.\n"));
6589
6590       return TRUE;
6591     }
6592
6593   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6594
6595   if (section_groups == NULL)
6596     {
6597       error (_("Out of memory reading %lu groups\n"),
6598              (unsigned long) group_count);
6599       return FALSE;
6600     }
6601
6602   symtab_sec = NULL;
6603   strtab_sec = NULL;
6604   symtab = NULL;
6605   num_syms = 0;
6606   strtab = NULL;
6607   strtab_size = 0;
6608   for (i = 0, section = section_headers, group = section_groups;
6609        i < elf_header.e_shnum;
6610        i++, section++)
6611     {
6612       if (section->sh_type == SHT_GROUP)
6613         {
6614           const char * name = printable_section_name (section);
6615           const char * group_name;
6616           unsigned char * start;
6617           unsigned char * indices;
6618           unsigned int entry, j, size;
6619           Elf_Internal_Shdr * sec;
6620           Elf_Internal_Sym * sym;
6621
6622           /* Get the symbol table.  */
6623           if (section->sh_link >= elf_header.e_shnum
6624               || ((sec = section_headers + section->sh_link)->sh_type
6625                   != SHT_SYMTAB))
6626             {
6627               error (_("Bad sh_link in group section `%s'\n"), name);
6628               continue;
6629             }
6630
6631           if (symtab_sec != sec)
6632             {
6633               symtab_sec = sec;
6634               if (symtab)
6635                 free (symtab);
6636               symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6637             }
6638
6639           if (symtab == NULL)
6640             {
6641               error (_("Corrupt header in group section `%s'\n"), name);
6642               continue;
6643             }
6644
6645           if (section->sh_info >= num_syms)
6646             {
6647               error (_("Bad sh_info in group section `%s'\n"), name);
6648               continue;
6649             }
6650
6651           sym = symtab + section->sh_info;
6652
6653           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6654             {
6655               if (sym->st_shndx == 0
6656                   || sym->st_shndx >= elf_header.e_shnum)
6657                 {
6658                   error (_("Bad sh_info in group section `%s'\n"), name);
6659                   continue;
6660                 }
6661
6662               group_name = SECTION_NAME (section_headers + sym->st_shndx);
6663               strtab_sec = NULL;
6664               if (strtab)
6665                 free (strtab);
6666               strtab = NULL;
6667               strtab_size = 0;
6668             }
6669           else
6670             {
6671               /* Get the string table.  */
6672               if (symtab_sec->sh_link >= elf_header.e_shnum)
6673                 {
6674                   strtab_sec = NULL;
6675                   if (strtab)
6676                     free (strtab);
6677                   strtab = NULL;
6678                   strtab_size = 0;
6679                 }
6680               else if (strtab_sec
6681                        != (sec = section_headers + symtab_sec->sh_link))
6682                 {
6683                   strtab_sec = sec;
6684                   if (strtab)
6685                     free (strtab);
6686
6687                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6688                                               1, strtab_sec->sh_size,
6689                                               _("string table"));
6690                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6691                 }
6692               group_name = sym->st_name < strtab_size
6693                 ? strtab + sym->st_name : _("<corrupt>");
6694             }
6695
6696           /* PR 17531: file: loop.  */
6697           if (section->sh_entsize > section->sh_size)
6698             {
6699               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6700                      printable_section_name (section),
6701                      (unsigned long) section->sh_entsize,
6702                      (unsigned long) section->sh_size);
6703               break;
6704             }
6705
6706           start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6707                                               1, section->sh_size,
6708                                               _("section data"));
6709           if (start == NULL)
6710             continue;
6711
6712           indices = start;
6713           size = (section->sh_size / section->sh_entsize) - 1;
6714           entry = byte_get (indices, 4);
6715           indices += 4;
6716
6717           if (do_section_groups)
6718             {
6719               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6720                       get_group_flags (entry), i, name, group_name, size);
6721
6722               printf (_("   [Index]    Name\n"));
6723             }
6724
6725           group->group_index = i;
6726
6727           for (j = 0; j < size; j++)
6728             {
6729               struct group_list * g;
6730
6731               entry = byte_get (indices, 4);
6732               indices += 4;
6733
6734               if (entry >= elf_header.e_shnum)
6735                 {
6736                   static unsigned num_group_errors = 0;
6737
6738                   if (num_group_errors ++ < 10)
6739                     {
6740                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6741                              entry, i, elf_header.e_shnum - 1);
6742                       if (num_group_errors == 10)
6743                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6744                     }
6745                   continue;
6746                 }
6747
6748               if (section_headers_groups [entry] != NULL)
6749                 {
6750                   if (entry)
6751                     {
6752                       static unsigned num_errs = 0;
6753
6754                       if (num_errs ++ < 10)
6755                         {
6756                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6757                                  entry, i,
6758                                  section_headers_groups [entry]->group_index);
6759                           if (num_errs == 10)
6760                             warn (_("Further error messages about already contained group sections suppressed\n"));
6761                         }
6762                       continue;
6763                     }
6764                   else
6765                     {
6766                       /* Intel C/C++ compiler may put section 0 in a
6767                          section group.  We just warn it the first time
6768                          and ignore it afterwards.  */
6769                       static bfd_boolean warned = FALSE;
6770                       if (!warned)
6771                         {
6772                           error (_("section 0 in group section [%5u]\n"),
6773                                  section_headers_groups [entry]->group_index);
6774                           warned = TRUE;
6775                         }
6776                     }
6777                 }
6778
6779               section_headers_groups [entry] = group;
6780
6781               if (do_section_groups)
6782                 {
6783                   sec = section_headers + entry;
6784                   printf ("   [%5u]   %s\n", entry, printable_section_name (sec));
6785                 }
6786
6787               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6788               g->section_index = entry;
6789               g->next = group->root;
6790               group->root = g;
6791             }
6792
6793           if (start)
6794             free (start);
6795
6796           group++;
6797         }
6798     }
6799
6800   if (symtab)
6801     free (symtab);
6802   if (strtab)
6803     free (strtab);
6804   return TRUE;
6805 }
6806
6807 /* Data used to display dynamic fixups.  */
6808
6809 struct ia64_vms_dynfixup
6810 {
6811   bfd_vma needed_ident;         /* Library ident number.  */
6812   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6813   bfd_vma fixup_needed;         /* Index of the library.  */
6814   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6815   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6816 };
6817
6818 /* Data used to display dynamic relocations.  */
6819
6820 struct ia64_vms_dynimgrela
6821 {
6822   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6823   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6824 };
6825
6826 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6827    library).  */
6828
6829 static bfd_boolean
6830 dump_ia64_vms_dynamic_fixups (FILE * file,
6831                               struct ia64_vms_dynfixup * fixup,
6832                               const char * strtab,
6833                               unsigned int strtab_sz)
6834 {
6835   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6836   long i;
6837   const char * lib_name;
6838
6839   imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6840                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6841                    _("dynamic section image fixups"));
6842   if (!imfs)
6843     return FALSE;
6844
6845   if (fixup->needed < strtab_sz)
6846     lib_name = strtab + fixup->needed;
6847   else
6848     {
6849       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6850             (unsigned long) fixup->needed);
6851       lib_name = "???";
6852     }
6853   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6854           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6855   printf
6856     (_("Seg Offset           Type                             SymVec DataType\n"));
6857
6858   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6859     {
6860       unsigned int type;
6861       const char *rtype;
6862
6863       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6864       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6865       type = BYTE_GET (imfs [i].type);
6866       rtype = elf_ia64_reloc_type (type);
6867       if (rtype == NULL)
6868         printf (" 0x%08x                       ", type);
6869       else
6870         printf (" %-32s ", rtype);
6871       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6872       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6873     }
6874
6875   free (imfs);
6876   return TRUE;
6877 }
6878
6879 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6880
6881 static bfd_boolean
6882 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6883 {
6884   Elf64_External_VMS_IMAGE_RELA *imrs;
6885   long i;
6886
6887   imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6888                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6889                    _("dynamic section image relocations"));
6890   if (!imrs)
6891     return FALSE;
6892
6893   printf (_("\nImage relocs\n"));
6894   printf
6895     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6896
6897   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6898     {
6899       unsigned int type;
6900       const char *rtype;
6901
6902       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6903       printf ("%08" BFD_VMA_FMT "x ",
6904               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6905       type = BYTE_GET (imrs [i].type);
6906       rtype = elf_ia64_reloc_type (type);
6907       if (rtype == NULL)
6908         printf ("0x%08x                      ", type);
6909       else
6910         printf ("%-31s ", rtype);
6911       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6912       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6913       printf ("%08" BFD_VMA_FMT "x\n",
6914               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6915     }
6916
6917   free (imrs);
6918   return TRUE;
6919 }
6920
6921 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6922
6923 static bfd_boolean
6924 process_ia64_vms_dynamic_relocs (FILE *file)
6925 {
6926   struct ia64_vms_dynfixup fixup;
6927   struct ia64_vms_dynimgrela imgrela;
6928   Elf_Internal_Dyn *entry;
6929   bfd_vma strtab_off = 0;
6930   bfd_vma strtab_sz = 0;
6931   char *strtab = NULL;
6932   bfd_boolean res = TRUE;
6933
6934   memset (&fixup, 0, sizeof (fixup));
6935   memset (&imgrela, 0, sizeof (imgrela));
6936
6937   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6938   for (entry = dynamic_section;
6939        entry < dynamic_section + dynamic_nent;
6940        entry++)
6941     {
6942       switch (entry->d_tag)
6943         {
6944         case DT_IA_64_VMS_STRTAB_OFFSET:
6945           strtab_off = entry->d_un.d_val;
6946           break;
6947         case DT_STRSZ:
6948           strtab_sz = entry->d_un.d_val;
6949           if (strtab == NULL)
6950             strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6951                                1, strtab_sz, _("dynamic string section"));
6952           break;
6953
6954         case DT_IA_64_VMS_NEEDED_IDENT:
6955           fixup.needed_ident = entry->d_un.d_val;
6956           break;
6957         case DT_NEEDED:
6958           fixup.needed = entry->d_un.d_val;
6959           break;
6960         case DT_IA_64_VMS_FIXUP_NEEDED:
6961           fixup.fixup_needed = entry->d_un.d_val;
6962           break;
6963         case DT_IA_64_VMS_FIXUP_RELA_CNT:
6964           fixup.fixup_rela_cnt = entry->d_un.d_val;
6965           break;
6966         case DT_IA_64_VMS_FIXUP_RELA_OFF:
6967           fixup.fixup_rela_off = entry->d_un.d_val;
6968           if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6969             res = FALSE;
6970           break;
6971         case DT_IA_64_VMS_IMG_RELA_CNT:
6972           imgrela.img_rela_cnt = entry->d_un.d_val;
6973           break;
6974         case DT_IA_64_VMS_IMG_RELA_OFF:
6975           imgrela.img_rela_off = entry->d_un.d_val;
6976           if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6977             res = FALSE;
6978           break;
6979
6980         default:
6981           break;
6982         }
6983     }
6984
6985   if (strtab != NULL)
6986     free (strtab);
6987
6988   return res;
6989 }
6990
6991 static struct
6992 {
6993   const char * name;
6994   int reloc;
6995   int size;
6996   int rela;
6997 }
6998   dynamic_relocations [] =
6999 {
7000   { "REL", DT_REL, DT_RELSZ, FALSE },
7001   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7002   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7003 };
7004
7005 /* Process the reloc section.  */
7006
7007 static bfd_boolean
7008 process_relocs (FILE * file)
7009 {
7010   unsigned long rel_size;
7011   unsigned long rel_offset;
7012
7013   if (!do_reloc)
7014     return TRUE;
7015
7016   if (do_using_dynamic)
7017     {
7018       int          is_rela;
7019       const char * name;
7020       bfd_boolean  has_dynamic_reloc;
7021       unsigned int i;
7022
7023       has_dynamic_reloc = FALSE;
7024
7025       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7026         {
7027           is_rela = dynamic_relocations [i].rela;
7028           name = dynamic_relocations [i].name;
7029           rel_size = dynamic_info [dynamic_relocations [i].size];
7030           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7031
7032           if (rel_size)
7033             has_dynamic_reloc = TRUE;
7034
7035           if (is_rela == UNKNOWN)
7036             {
7037               if (dynamic_relocations [i].reloc == DT_JMPREL)
7038                 switch (dynamic_info[DT_PLTREL])
7039                   {
7040                   case DT_REL:
7041                     is_rela = FALSE;
7042                     break;
7043                   case DT_RELA:
7044                     is_rela = TRUE;
7045                     break;
7046                   }
7047             }
7048
7049           if (rel_size)
7050             {
7051               printf
7052                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7053                  name, rel_offset, rel_size);
7054
7055               dump_relocations (file,
7056                                 offset_from_vma (file, rel_offset, rel_size),
7057                                 rel_size,
7058                                 dynamic_symbols, num_dynamic_syms,
7059                                 dynamic_strings, dynamic_strings_length,
7060                                 is_rela, TRUE /* is_dynamic */);
7061             }
7062         }
7063
7064       if (is_ia64_vms ())
7065         if (process_ia64_vms_dynamic_relocs (file))
7066           has_dynamic_reloc = TRUE;
7067
7068       if (! has_dynamic_reloc)
7069         printf (_("\nThere are no dynamic relocations in this file.\n"));
7070     }
7071   else
7072     {
7073       Elf_Internal_Shdr * section;
7074       unsigned long i;
7075       bfd_boolean found = FALSE;
7076
7077       for (i = 0, section = section_headers;
7078            i < elf_header.e_shnum;
7079            i++, section++)
7080         {
7081           if (   section->sh_type != SHT_RELA
7082               && section->sh_type != SHT_REL)
7083             continue;
7084
7085           rel_offset = section->sh_offset;
7086           rel_size   = section->sh_size;
7087
7088           if (rel_size)
7089             {
7090               Elf_Internal_Shdr * strsec;
7091               int is_rela;
7092
7093               printf (_("\nRelocation section "));
7094
7095               if (string_table == NULL)
7096                 printf ("%d", section->sh_name);
7097               else
7098                 printf ("'%s'", printable_section_name (section));
7099
7100               printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101                  rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7102
7103               is_rela = section->sh_type == SHT_RELA;
7104
7105               if (section->sh_link != 0
7106                   && section->sh_link < elf_header.e_shnum)
7107                 {
7108                   Elf_Internal_Shdr * symsec;
7109                   Elf_Internal_Sym *  symtab;
7110                   unsigned long nsyms;
7111                   unsigned long strtablen = 0;
7112                   char * strtab = NULL;
7113
7114                   symsec = section_headers + section->sh_link;
7115                   if (symsec->sh_type != SHT_SYMTAB
7116                       && symsec->sh_type != SHT_DYNSYM)
7117                     continue;
7118
7119                   symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7120
7121                   if (symtab == NULL)
7122                     continue;
7123
7124                   if (symsec->sh_link != 0
7125                       && symsec->sh_link < elf_header.e_shnum)
7126                     {
7127                       strsec = section_headers + symsec->sh_link;
7128
7129                       strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7130                                                   1, strsec->sh_size,
7131                                                   _("string table"));
7132                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7133                     }
7134
7135                   dump_relocations (file, rel_offset, rel_size,
7136                                     symtab, nsyms, strtab, strtablen,
7137                                     is_rela,
7138                                     symsec->sh_type == SHT_DYNSYM);
7139                   if (strtab)
7140                     free (strtab);
7141                   free (symtab);
7142                 }
7143               else
7144                 dump_relocations (file, rel_offset, rel_size,
7145                                   NULL, 0, NULL, 0, is_rela,
7146                                   FALSE /* is_dynamic */);
7147
7148               found = TRUE;
7149             }
7150         }
7151
7152       if (! found)
7153         printf (_("\nThere are no relocations in this file.\n"));
7154     }
7155
7156   return TRUE;
7157 }
7158
7159 /* An absolute address consists of a section and an offset.  If the
7160    section is NULL, the offset itself is the address, otherwise, the
7161    address equals to LOAD_ADDRESS(section) + offset.  */
7162
7163 struct absaddr
7164 {
7165   unsigned short section;
7166   bfd_vma offset;
7167 };
7168
7169 #define ABSADDR(a) \
7170   ((a).section \
7171    ? section_headers [(a).section].sh_addr + (a).offset \
7172    : (a).offset)
7173
7174 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7175    name, if found, and the offset from the symbol to ADDR.  */
7176
7177 static void
7178 find_symbol_for_address (Elf_Internal_Sym * symtab,
7179                          unsigned long      nsyms,
7180                          const char *       strtab,
7181                          unsigned long      strtab_size,
7182                          struct absaddr     addr,
7183                          const char **      symname,
7184                          bfd_vma *          offset)
7185 {
7186   bfd_vma dist = 0x100000;
7187   Elf_Internal_Sym * sym;
7188   Elf_Internal_Sym * beg;
7189   Elf_Internal_Sym * end;
7190   Elf_Internal_Sym * best = NULL;
7191
7192   REMOVE_ARCH_BITS (addr.offset);
7193   beg = symtab;
7194   end = symtab + nsyms;
7195
7196   while (beg < end)
7197     {
7198       bfd_vma value;
7199
7200       sym = beg + (end - beg) / 2;
7201
7202       value = sym->st_value;
7203       REMOVE_ARCH_BITS (value);
7204
7205       if (sym->st_name != 0
7206           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7207           && addr.offset >= value
7208           && addr.offset - value < dist)
7209         {
7210           best = sym;
7211           dist = addr.offset - value;
7212           if (!dist)
7213             break;
7214         }
7215
7216       if (addr.offset < value)
7217         end = sym;
7218       else
7219         beg = sym + 1;
7220     }
7221
7222   if (best)
7223     {
7224       *symname = (best->st_name >= strtab_size
7225                   ? _("<corrupt>") : strtab + best->st_name);
7226       *offset = dist;
7227       return;
7228     }
7229
7230   *symname = NULL;
7231   *offset = addr.offset;
7232 }
7233
7234 static /* signed */ int
7235 symcmp (const void *p, const void *q)
7236 {
7237   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7238   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7239
7240   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7241 }
7242
7243 /* Process the unwind section.  */
7244
7245 #include "unwind-ia64.h"
7246
7247 struct ia64_unw_table_entry
7248 {
7249   struct absaddr start;
7250   struct absaddr end;
7251   struct absaddr info;
7252 };
7253
7254 struct ia64_unw_aux_info
7255 {
7256   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7257   unsigned long                 table_len;      /* Length of unwind table.  */
7258   unsigned char *               info;           /* Unwind info.  */
7259   unsigned long                 info_size;      /* Size of unwind info.  */
7260   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7261   bfd_vma                       seg_base;       /* Starting address of segment.  */
7262   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7263   unsigned long                 nsyms;          /* Number of symbols.  */
7264   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7265   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7266   char *                        strtab;         /* The string table.  */
7267   unsigned long                 strtab_size;    /* Size of string table.  */
7268 };
7269
7270 static bfd_boolean
7271 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7272 {
7273   struct ia64_unw_table_entry * tp;
7274   unsigned long j, nfuns;
7275   int in_body;
7276   bfd_boolean res = TRUE;
7277
7278   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7279   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7280     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7281       aux->funtab[nfuns++] = aux->symtab[j];
7282   aux->nfuns = nfuns;
7283   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7284
7285   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7286     {
7287       bfd_vma stamp;
7288       bfd_vma offset;
7289       const unsigned char * dp;
7290       const unsigned char * head;
7291       const unsigned char * end;
7292       const char * procname;
7293
7294       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7295                                aux->strtab_size, tp->start, &procname, &offset);
7296
7297       fputs ("\n<", stdout);
7298
7299       if (procname)
7300         {
7301           fputs (procname, stdout);
7302
7303           if (offset)
7304             printf ("+%lx", (unsigned long) offset);
7305         }
7306
7307       fputs (">: [", stdout);
7308       print_vma (tp->start.offset, PREFIX_HEX);
7309       fputc ('-', stdout);
7310       print_vma (tp->end.offset, PREFIX_HEX);
7311       printf ("], info at +0x%lx\n",
7312               (unsigned long) (tp->info.offset - aux->seg_base));
7313
7314       /* PR 17531: file: 86232b32.  */
7315       if (aux->info == NULL)
7316         continue;
7317
7318       /* PR 17531: file: 0997b4d1.  */
7319       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7320         {
7321           warn (_("Invalid offset %lx in table entry %ld\n"),
7322                 (long) tp->info.offset, (long) (tp - aux->table));
7323           res = FALSE;
7324           continue;
7325         }
7326
7327       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7328       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7329
7330       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7331               (unsigned) UNW_VER (stamp),
7332               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7333               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7334               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7335               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7336
7337       if (UNW_VER (stamp) != 1)
7338         {
7339           printf (_("\tUnknown version.\n"));
7340           continue;
7341         }
7342
7343       in_body = 0;
7344       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7345       /* PR 17531: file: 16ceda89.  */
7346       if (end > aux->info + aux->info_size)
7347         end = aux->info + aux->info_size;
7348       for (dp = head + 8; dp < end;)
7349         dp = unw_decode (dp, in_body, & in_body, end);
7350     }
7351
7352   free (aux->funtab);
7353
7354   return res;
7355 }
7356
7357 static bfd_boolean
7358 slurp_ia64_unwind_table (FILE * file,
7359                          struct ia64_unw_aux_info * aux,
7360                          Elf_Internal_Shdr * sec)
7361 {
7362   unsigned long size, nrelas, i;
7363   Elf_Internal_Phdr * seg;
7364   struct ia64_unw_table_entry * tep;
7365   Elf_Internal_Shdr * relsec;
7366   Elf_Internal_Rela * rela;
7367   Elf_Internal_Rela * rp;
7368   unsigned char * table;
7369   unsigned char * tp;
7370   Elf_Internal_Sym * sym;
7371   const char * relname;
7372
7373   aux->table_len = 0;
7374
7375   /* First, find the starting address of the segment that includes
7376      this section: */
7377
7378   if (elf_header.e_phnum)
7379     {
7380       if (! get_program_headers (file))
7381           return FALSE;
7382
7383       for (seg = program_headers;
7384            seg < program_headers + elf_header.e_phnum;
7385            ++seg)
7386         {
7387           if (seg->p_type != PT_LOAD)
7388             continue;
7389
7390           if (sec->sh_addr >= seg->p_vaddr
7391               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7392             {
7393               aux->seg_base = seg->p_vaddr;
7394               break;
7395             }
7396         }
7397     }
7398
7399   /* Second, build the unwind table from the contents of the unwind section:  */
7400   size = sec->sh_size;
7401   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7402                                       _("unwind table"));
7403   if (!table)
7404     return FALSE;
7405
7406   aux->table_len = size / (3 * eh_addr_size);
7407   aux->table = (struct ia64_unw_table_entry *)
7408     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7409   tep = aux->table;
7410
7411   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7412     {
7413       tep->start.section = SHN_UNDEF;
7414       tep->end.section   = SHN_UNDEF;
7415       tep->info.section  = SHN_UNDEF;
7416       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7417       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7418       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7419       tep->start.offset += aux->seg_base;
7420       tep->end.offset   += aux->seg_base;
7421       tep->info.offset  += aux->seg_base;
7422     }
7423   free (table);
7424
7425   /* Third, apply any relocations to the unwind table:  */
7426   for (relsec = section_headers;
7427        relsec < section_headers + elf_header.e_shnum;
7428        ++relsec)
7429     {
7430       if (relsec->sh_type != SHT_RELA
7431           || relsec->sh_info >= elf_header.e_shnum
7432           || section_headers + relsec->sh_info != sec)
7433         continue;
7434
7435       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7436                               & rela, & nrelas))
7437         {
7438           free (aux->table);
7439           aux->table = NULL;
7440           aux->table_len = 0;
7441           return FALSE;
7442         }
7443
7444       for (rp = rela; rp < rela + nrelas; ++rp)
7445         {
7446           relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7447           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7448
7449           /* PR 17531: file: 9fa67536.  */
7450           if (relname == NULL)
7451             {
7452               warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7453               continue;
7454             }
7455
7456           if (! const_strneq (relname, "R_IA64_SEGREL"))
7457             {
7458               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7459               continue;
7460             }
7461
7462           i = rp->r_offset / (3 * eh_addr_size);
7463
7464           /* PR 17531: file: 5bc8d9bf.  */
7465           if (i >= aux->table_len)
7466             {
7467               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7468               continue;
7469             }
7470
7471           switch (rp->r_offset / eh_addr_size % 3)
7472             {
7473             case 0:
7474               aux->table[i].start.section = sym->st_shndx;
7475               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7476               break;
7477             case 1:
7478               aux->table[i].end.section   = sym->st_shndx;
7479               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7480               break;
7481             case 2:
7482               aux->table[i].info.section  = sym->st_shndx;
7483               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7484               break;
7485             default:
7486               break;
7487             }
7488         }
7489
7490       free (rela);
7491     }
7492
7493   return TRUE;
7494 }
7495
7496 static bfd_boolean
7497 ia64_process_unwind (FILE * file)
7498 {
7499   Elf_Internal_Shdr * sec;
7500   Elf_Internal_Shdr * unwsec = NULL;
7501   Elf_Internal_Shdr * strsec;
7502   unsigned long i, unwcount = 0, unwstart = 0;
7503   struct ia64_unw_aux_info aux;
7504   bfd_boolean res = TRUE;
7505
7506   memset (& aux, 0, sizeof (aux));
7507
7508   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7509     {
7510       if (sec->sh_type == SHT_SYMTAB
7511           && sec->sh_link < elf_header.e_shnum)
7512         {
7513           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7514
7515           strsec = section_headers + sec->sh_link;
7516           if (aux.strtab != NULL)
7517             {
7518               error (_("Multiple auxillary string tables encountered\n"));
7519               free (aux.strtab);
7520               res = FALSE;
7521             }
7522           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7523                                           1, strsec->sh_size,
7524                                           _("string table"));
7525           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7526         }
7527       else if (sec->sh_type == SHT_IA_64_UNWIND)
7528         unwcount++;
7529     }
7530
7531   if (!unwcount)
7532     printf (_("\nThere are no unwind sections in this file.\n"));
7533
7534   while (unwcount-- > 0)
7535     {
7536       char * suffix;
7537       size_t len, len2;
7538
7539       for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7540            i < elf_header.e_shnum; ++i, ++sec)
7541         if (sec->sh_type == SHT_IA_64_UNWIND)
7542           {
7543             unwsec = sec;
7544             break;
7545           }
7546       /* We have already counted the number of SHT_IA64_UNWIND
7547          sections so the loop above should never fail.  */
7548       assert (unwsec != NULL);
7549
7550       unwstart = i + 1;
7551       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7552
7553       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7554         {
7555           /* We need to find which section group it is in.  */
7556           struct group_list * g;
7557
7558           if (section_headers_groups == NULL
7559               || section_headers_groups [i] == NULL)
7560             i = elf_header.e_shnum;
7561           else
7562             {
7563               g = section_headers_groups [i]->root;
7564
7565               for (; g != NULL; g = g->next)
7566                 {
7567                   sec = section_headers + g->section_index;
7568
7569                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7570                     break;
7571                 }
7572
7573               if (g == NULL)
7574                 i = elf_header.e_shnum;
7575             }
7576         }
7577       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7578         {
7579           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7580           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7581           suffix = SECTION_NAME (unwsec) + len;
7582           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7583                ++i, ++sec)
7584             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7585                 && streq (SECTION_NAME (sec) + len2, suffix))
7586               break;
7587         }
7588       else
7589         {
7590           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7591              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7592           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7593           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7594           suffix = "";
7595           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7596             suffix = SECTION_NAME (unwsec) + len;
7597           for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7598                ++i, ++sec)
7599             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7600                 && streq (SECTION_NAME (sec) + len2, suffix))
7601               break;
7602         }
7603
7604       if (i == elf_header.e_shnum)
7605         {
7606           printf (_("\nCould not find unwind info section for "));
7607
7608           if (string_table == NULL)
7609             printf ("%d", unwsec->sh_name);
7610           else
7611             printf ("'%s'", printable_section_name (unwsec));
7612         }
7613       else
7614         {
7615           aux.info_addr = sec->sh_addr;
7616           aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7617                                                  sec->sh_size,
7618                                                  _("unwind info"));
7619           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7620
7621           printf (_("\nUnwind section "));
7622
7623           if (string_table == NULL)
7624             printf ("%d", unwsec->sh_name);
7625           else
7626             printf ("'%s'", printable_section_name (unwsec));
7627
7628           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7629                   (unsigned long) unwsec->sh_offset,
7630                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7631
7632           if (slurp_ia64_unwind_table (file, & aux, unwsec)
7633               && aux.table_len > 0)
7634             dump_ia64_unwind (& aux);
7635
7636           if (aux.table)
7637             free ((char *) aux.table);
7638           if (aux.info)
7639             free ((char *) aux.info);
7640           aux.table = NULL;
7641           aux.info = NULL;
7642         }
7643     }
7644
7645   if (aux.symtab)
7646     free (aux.symtab);
7647   if (aux.strtab)
7648     free ((char *) aux.strtab);
7649
7650   return res;
7651 }
7652
7653 struct hppa_unw_table_entry
7654 {
7655   struct absaddr start;
7656   struct absaddr end;
7657   unsigned int Cannot_unwind:1;                 /* 0 */
7658   unsigned int Millicode:1;                     /* 1 */
7659   unsigned int Millicode_save_sr0:1;            /* 2 */
7660   unsigned int Region_description:2;            /* 3..4 */
7661   unsigned int reserved1:1;                     /* 5 */
7662   unsigned int Entry_SR:1;                      /* 6 */
7663   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7664   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7665   unsigned int Args_stored:1;                   /* 16 */
7666   unsigned int Variable_Frame:1;                /* 17 */
7667   unsigned int Separate_Package_Body:1;         /* 18 */
7668   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7669   unsigned int Stack_Overflow_Check:1;          /* 20 */
7670   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7671   unsigned int Ada_Region:1;                    /* 22 */
7672   unsigned int cxx_info:1;                      /* 23 */
7673   unsigned int cxx_try_catch:1;                 /* 24 */
7674   unsigned int sched_entry_seq:1;               /* 25 */
7675   unsigned int reserved2:1;                     /* 26 */
7676   unsigned int Save_SP:1;                       /* 27 */
7677   unsigned int Save_RP:1;                       /* 28 */
7678   unsigned int Save_MRP_in_frame:1;             /* 29 */
7679   unsigned int extn_ptr_defined:1;              /* 30 */
7680   unsigned int Cleanup_defined:1;               /* 31 */
7681
7682   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7683   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7684   unsigned int Large_frame:1;                   /* 2 */
7685   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7686   unsigned int reserved4:1;                     /* 4 */
7687   unsigned int Total_frame_size:27;             /* 5..31 */
7688 };
7689
7690 struct hppa_unw_aux_info
7691 {
7692   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7693   unsigned long                  table_len;     /* Length of unwind table.  */
7694   bfd_vma                        seg_base;      /* Starting address of segment.  */
7695   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7696   unsigned long                  nsyms;         /* Number of symbols.  */
7697   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7698   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7699   char *                         strtab;        /* The string table.  */
7700   unsigned long                  strtab_size;   /* Size of string table.  */
7701 };
7702
7703 static bfd_boolean
7704 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7705 {
7706   struct hppa_unw_table_entry * tp;
7707   unsigned long j, nfuns;
7708   bfd_boolean res = TRUE;
7709
7710   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7711   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7712     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7713       aux->funtab[nfuns++] = aux->symtab[j];
7714   aux->nfuns = nfuns;
7715   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7716
7717   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7718     {
7719       bfd_vma offset;
7720       const char * procname;
7721
7722       find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7723                                aux->strtab_size, tp->start, &procname,
7724                                &offset);
7725
7726       fputs ("\n<", stdout);
7727
7728       if (procname)
7729         {
7730           fputs (procname, stdout);
7731
7732           if (offset)
7733             printf ("+%lx", (unsigned long) offset);
7734         }
7735
7736       fputs (">: [", stdout);
7737       print_vma (tp->start.offset, PREFIX_HEX);
7738       fputc ('-', stdout);
7739       print_vma (tp->end.offset, PREFIX_HEX);
7740       printf ("]\n\t");
7741
7742 #define PF(_m) if (tp->_m) printf (#_m " ");
7743 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7744       PF(Cannot_unwind);
7745       PF(Millicode);
7746       PF(Millicode_save_sr0);
7747       /* PV(Region_description);  */
7748       PF(Entry_SR);
7749       PV(Entry_FR);
7750       PV(Entry_GR);
7751       PF(Args_stored);
7752       PF(Variable_Frame);
7753       PF(Separate_Package_Body);
7754       PF(Frame_Extension_Millicode);
7755       PF(Stack_Overflow_Check);
7756       PF(Two_Instruction_SP_Increment);
7757       PF(Ada_Region);
7758       PF(cxx_info);
7759       PF(cxx_try_catch);
7760       PF(sched_entry_seq);
7761       PF(Save_SP);
7762       PF(Save_RP);
7763       PF(Save_MRP_in_frame);
7764       PF(extn_ptr_defined);
7765       PF(Cleanup_defined);
7766       PF(MPE_XL_interrupt_marker);
7767       PF(HP_UX_interrupt_marker);
7768       PF(Large_frame);
7769       PF(Pseudo_SP_Set);
7770       PV(Total_frame_size);
7771 #undef PF
7772 #undef PV
7773     }
7774
7775   printf ("\n");
7776
7777   free (aux->funtab);
7778
7779   return res;
7780 }
7781
7782 static bfd_boolean
7783 slurp_hppa_unwind_table (FILE * file,
7784                          struct hppa_unw_aux_info * aux,
7785                          Elf_Internal_Shdr * sec)
7786 {
7787   unsigned long size, unw_ent_size, nentries, nrelas, i;
7788   Elf_Internal_Phdr * seg;
7789   struct hppa_unw_table_entry * tep;
7790   Elf_Internal_Shdr * relsec;
7791   Elf_Internal_Rela * rela;
7792   Elf_Internal_Rela * rp;
7793   unsigned char * table;
7794   unsigned char * tp;
7795   Elf_Internal_Sym * sym;
7796   const char * relname;
7797
7798   /* First, find the starting address of the segment that includes
7799      this section.  */
7800   if (elf_header.e_phnum)
7801     {
7802       if (! get_program_headers (file))
7803         return FALSE;
7804
7805       for (seg = program_headers;
7806            seg < program_headers + elf_header.e_phnum;
7807            ++seg)
7808         {
7809           if (seg->p_type != PT_LOAD)
7810             continue;
7811
7812           if (sec->sh_addr >= seg->p_vaddr
7813               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7814             {
7815               aux->seg_base = seg->p_vaddr;
7816               break;
7817             }
7818         }
7819     }
7820
7821   /* Second, build the unwind table from the contents of the unwind
7822      section.  */
7823   size = sec->sh_size;
7824   table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7825                                       _("unwind table"));
7826   if (!table)
7827     return FALSE;
7828
7829   unw_ent_size = 16;
7830   nentries = size / unw_ent_size;
7831   size = unw_ent_size * nentries;
7832
7833   tep = aux->table = (struct hppa_unw_table_entry *)
7834       xcmalloc (nentries, sizeof (aux->table[0]));
7835
7836   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7837     {
7838       unsigned int tmp1, tmp2;
7839
7840       tep->start.section = SHN_UNDEF;
7841       tep->end.section   = SHN_UNDEF;
7842
7843       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7844       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7845       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7846       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7847
7848       tep->start.offset += aux->seg_base;
7849       tep->end.offset   += aux->seg_base;
7850
7851       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7852       tep->Millicode = (tmp1 >> 30) & 0x1;
7853       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7854       tep->Region_description = (tmp1 >> 27) & 0x3;
7855       tep->reserved1 = (tmp1 >> 26) & 0x1;
7856       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7857       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7858       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7859       tep->Args_stored = (tmp1 >> 15) & 0x1;
7860       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7861       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7862       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7863       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7864       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7865       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7866       tep->cxx_info = (tmp1 >> 8) & 0x1;
7867       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7868       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7869       tep->reserved2 = (tmp1 >> 5) & 0x1;
7870       tep->Save_SP = (tmp1 >> 4) & 0x1;
7871       tep->Save_RP = (tmp1 >> 3) & 0x1;
7872       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7873       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7874       tep->Cleanup_defined = tmp1 & 0x1;
7875
7876       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7877       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7878       tep->Large_frame = (tmp2 >> 29) & 0x1;
7879       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7880       tep->reserved4 = (tmp2 >> 27) & 0x1;
7881       tep->Total_frame_size = tmp2 & 0x7ffffff;
7882     }
7883   free (table);
7884
7885   /* Third, apply any relocations to the unwind table.  */
7886   for (relsec = section_headers;
7887        relsec < section_headers + elf_header.e_shnum;
7888        ++relsec)
7889     {
7890       if (relsec->sh_type != SHT_RELA
7891           || relsec->sh_info >= elf_header.e_shnum
7892           || section_headers + relsec->sh_info != sec)
7893         continue;
7894
7895       if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7896                               & rela, & nrelas))
7897         return FALSE;
7898
7899       for (rp = rela; rp < rela + nrelas; ++rp)
7900         {
7901           relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7902           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7903
7904           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7905           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7906             {
7907               warn (_("Skipping unexpected relocation type %s\n"), relname);
7908               continue;
7909             }
7910
7911           i = rp->r_offset / unw_ent_size;
7912
7913           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7914             {
7915             case 0:
7916               aux->table[i].start.section = sym->st_shndx;
7917               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7918               break;
7919             case 1:
7920               aux->table[i].end.section   = sym->st_shndx;
7921               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7922               break;
7923             default:
7924               break;
7925             }
7926         }
7927
7928       free (rela);
7929     }
7930
7931   aux->table_len = nentries;
7932
7933   return TRUE;
7934 }
7935
7936 static bfd_boolean
7937 hppa_process_unwind (FILE * file)
7938 {
7939   struct hppa_unw_aux_info aux;
7940   Elf_Internal_Shdr * unwsec = NULL;
7941   Elf_Internal_Shdr * strsec;
7942   Elf_Internal_Shdr * sec;
7943   unsigned long i;
7944   bfd_boolean res = TRUE;
7945
7946   if (string_table == NULL)
7947     return FALSE;
7948
7949   memset (& aux, 0, sizeof (aux));
7950
7951   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7952     {
7953       if (sec->sh_type == SHT_SYMTAB
7954           && sec->sh_link < elf_header.e_shnum)
7955         {
7956           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7957
7958           strsec = section_headers + sec->sh_link;
7959           if (aux.strtab != NULL)
7960             {
7961               error (_("Multiple auxillary string tables encountered\n"));
7962               free (aux.strtab);
7963               res = FALSE;
7964             }
7965           aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7966                                           1, strsec->sh_size,
7967                                           _("string table"));
7968           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7969         }
7970       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7971         unwsec = sec;
7972     }
7973
7974   if (!unwsec)
7975     printf (_("\nThere are no unwind sections in this file.\n"));
7976
7977   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7978     {
7979       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7980         {
7981           printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7982                   printable_section_name (sec),
7983                   (unsigned long) sec->sh_offset,
7984                   (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7985
7986           if (! slurp_hppa_unwind_table (file, &aux, sec))
7987             res = FALSE;
7988
7989           if (aux.table_len > 0)
7990             {
7991               if (! dump_hppa_unwind (&aux))
7992                 res = FALSE;
7993             }
7994
7995           if (aux.table)
7996             free ((char *) aux.table);
7997           aux.table = NULL;
7998         }
7999     }
8000
8001   if (aux.symtab)
8002     free (aux.symtab);
8003   if (aux.strtab)
8004     free ((char *) aux.strtab);
8005
8006   return res;
8007 }
8008
8009 struct arm_section
8010 {
8011   unsigned char *      data;            /* The unwind data.  */
8012   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8013   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8014   unsigned long        nrelas;          /* The number of relocations.  */
8015   unsigned int         rel_type;        /* REL or RELA ?  */
8016   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8017 };
8018
8019 struct arm_unw_aux_info
8020 {
8021   FILE *              file;             /* The file containing the unwind sections.  */
8022   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8023   unsigned long       nsyms;            /* Number of symbols.  */
8024   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8025   unsigned long       nfuns;            /* Number of these symbols.  */
8026   char *              strtab;           /* The file's string table.  */
8027   unsigned long       strtab_size;      /* Size of string table.  */
8028 };
8029
8030 static const char *
8031 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
8032                         bfd_vma fn, struct absaddr addr)
8033 {
8034   const char *procname;
8035   bfd_vma sym_offset;
8036
8037   if (addr.section == SHN_UNDEF)
8038     addr.offset = fn;
8039
8040   find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8041                            aux->strtab_size, addr, &procname,
8042                            &sym_offset);
8043
8044   print_vma (fn, PREFIX_HEX);
8045
8046   if (procname)
8047     {
8048       fputs (" <", stdout);
8049       fputs (procname, stdout);
8050
8051       if (sym_offset)
8052         printf ("+0x%lx", (unsigned long) sym_offset);
8053       fputc ('>', stdout);
8054     }
8055
8056   return procname;
8057 }
8058
8059 static void
8060 arm_free_section (struct arm_section *arm_sec)
8061 {
8062   if (arm_sec->data != NULL)
8063     free (arm_sec->data);
8064
8065   if (arm_sec->rela != NULL)
8066     free (arm_sec->rela);
8067 }
8068
8069 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8070       cached section and install SEC instead.
8071    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8072       and return its valued in * WORDP, relocating if necessary.
8073    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8074       relocation's offset in ADDR.
8075    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8076       into the string table of the symbol associated with the reloc.  If no
8077       reloc was applied store -1 there.
8078    5) Return TRUE upon success, FALSE otherwise.  */
8079
8080 static bfd_boolean
8081 get_unwind_section_word (struct arm_unw_aux_info *  aux,
8082                          struct arm_section *       arm_sec,
8083                          Elf_Internal_Shdr *        sec,
8084                          bfd_vma                    word_offset,
8085                          unsigned int *             wordp,
8086                          struct absaddr *           addr,
8087                          bfd_vma *                  sym_name)
8088 {
8089   Elf_Internal_Rela *rp;
8090   Elf_Internal_Sym *sym;
8091   const char * relname;
8092   unsigned int word;
8093   bfd_boolean wrapped;
8094
8095   if (sec == NULL || arm_sec == NULL)
8096     return FALSE;
8097
8098   addr->section = SHN_UNDEF;
8099   addr->offset = 0;
8100
8101   if (sym_name != NULL)
8102     *sym_name = (bfd_vma) -1;
8103
8104   /* If necessary, update the section cache.  */
8105   if (sec != arm_sec->sec)
8106     {
8107       Elf_Internal_Shdr *relsec;
8108
8109       arm_free_section (arm_sec);
8110
8111       arm_sec->sec = sec;
8112       arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8113                                 sec->sh_size, _("unwind data"));
8114       arm_sec->rela = NULL;
8115       arm_sec->nrelas = 0;
8116
8117       for (relsec = section_headers;
8118            relsec < section_headers + elf_header.e_shnum;
8119            ++relsec)
8120         {
8121           if (relsec->sh_info >= elf_header.e_shnum
8122               || section_headers + relsec->sh_info != sec
8123               /* PR 15745: Check the section type as well.  */
8124               || (relsec->sh_type != SHT_REL
8125                   && relsec->sh_type != SHT_RELA))
8126             continue;
8127
8128           arm_sec->rel_type = relsec->sh_type;
8129           if (relsec->sh_type == SHT_REL)
8130             {
8131               if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8132                                      relsec->sh_size,
8133                                      & arm_sec->rela, & arm_sec->nrelas))
8134                 return FALSE;
8135             }
8136           else /* relsec->sh_type == SHT_RELA */
8137             {
8138               if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8139                                       relsec->sh_size,
8140                                       & arm_sec->rela, & arm_sec->nrelas))
8141                 return FALSE;
8142             }
8143           break;
8144         }
8145
8146       arm_sec->next_rela = arm_sec->rela;
8147     }
8148
8149   /* If there is no unwind data we can do nothing.  */
8150   if (arm_sec->data == NULL)
8151     return FALSE;
8152
8153   /* If the offset is invalid then fail.  */
8154   if (/* PR 21343 *//* PR 18879 */
8155       sec->sh_size < 4
8156       || word_offset > (sec->sh_size - 4)
8157       || ((bfd_signed_vma) word_offset) < 0)
8158     return FALSE;
8159
8160   /* Get the word at the required offset.  */
8161   word = byte_get (arm_sec->data + word_offset, 4);
8162
8163   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8164   if (arm_sec->rela == NULL)
8165     {
8166       * wordp = word;
8167       return TRUE;
8168     }
8169
8170   /* Look through the relocs to find the one that applies to the provided offset.  */
8171   wrapped = FALSE;
8172   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8173     {
8174       bfd_vma prelval, offset;
8175
8176       if (rp->r_offset > word_offset && !wrapped)
8177         {
8178           rp = arm_sec->rela;
8179           wrapped = TRUE;
8180         }
8181       if (rp->r_offset > word_offset)
8182         break;
8183
8184       if (rp->r_offset & 3)
8185         {
8186           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8187                 (unsigned long) rp->r_offset);
8188           continue;
8189         }
8190
8191       if (rp->r_offset < word_offset)
8192         continue;
8193
8194       /* PR 17531: file: 027-161405-0.004  */
8195       if (aux->symtab == NULL)
8196         continue;
8197
8198       if (arm_sec->rel_type == SHT_REL)
8199         {
8200           offset = word & 0x7fffffff;
8201           if (offset & 0x40000000)
8202             offset |= ~ (bfd_vma) 0x7fffffff;
8203         }
8204       else if (arm_sec->rel_type == SHT_RELA)
8205         offset = rp->r_addend;
8206       else
8207         {
8208           error (_("Unknown section relocation type %d encountered\n"),
8209                  arm_sec->rel_type);
8210           break;
8211         }
8212
8213       /* PR 17531 file: 027-1241568-0.004.  */
8214       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8215         {
8216           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8217                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8218           break;
8219         }
8220
8221       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8222       offset += sym->st_value;
8223       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8224
8225       /* Check that we are processing the expected reloc type.  */
8226       if (elf_header.e_machine == EM_ARM)
8227         {
8228           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8229           if (relname == NULL)
8230             {
8231               warn (_("Skipping unknown ARM relocation type: %d\n"),
8232                     (int) ELF32_R_TYPE (rp->r_info));
8233               continue;
8234             }
8235
8236           if (streq (relname, "R_ARM_NONE"))
8237               continue;
8238
8239           if (! streq (relname, "R_ARM_PREL31"))
8240             {
8241               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8242               continue;
8243             }
8244         }
8245       else if (elf_header.e_machine == EM_TI_C6000)
8246         {
8247           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8248           if (relname == NULL)
8249             {
8250               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8251                     (int) ELF32_R_TYPE (rp->r_info));
8252               continue;
8253             }
8254
8255           if (streq (relname, "R_C6000_NONE"))
8256             continue;
8257
8258           if (! streq (relname, "R_C6000_PREL31"))
8259             {
8260               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8261               continue;
8262             }
8263
8264           prelval >>= 1;
8265         }
8266       else
8267         {
8268           /* This function currently only supports ARM and TI unwinders.  */
8269           warn (_("Only TI and ARM unwinders are currently supported\n"));
8270           break;
8271         }
8272
8273       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8274       addr->section = sym->st_shndx;
8275       addr->offset = offset;
8276
8277       if (sym_name)
8278         * sym_name = sym->st_name;
8279       break;
8280     }
8281
8282   *wordp = word;
8283   arm_sec->next_rela = rp;
8284
8285   return TRUE;
8286 }
8287
8288 static const char *tic6x_unwind_regnames[16] =
8289 {
8290   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8291   "A14", "A13", "A12", "A11", "A10",
8292   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8293 };
8294
8295 static void
8296 decode_tic6x_unwind_regmask (unsigned int mask)
8297 {
8298   int i;
8299
8300   for (i = 12; mask; mask >>= 1, i--)
8301     {
8302       if (mask & 1)
8303         {
8304           fputs (tic6x_unwind_regnames[i], stdout);
8305           if (mask > 1)
8306             fputs (", ", stdout);
8307         }
8308     }
8309 }
8310
8311 #define ADVANCE                                                 \
8312   if (remaining == 0 && more_words)                             \
8313     {                                                           \
8314       data_offset += 4;                                         \
8315       if (! get_unwind_section_word (aux, data_arm_sec, data_sec,       \
8316                                      data_offset, & word, & addr, NULL))        \
8317         return FALSE;                                           \
8318       remaining = 4;                                            \
8319       more_words--;                                             \
8320     }                                                           \
8321
8322 #define GET_OP(OP)                      \
8323   ADVANCE;                              \
8324   if (remaining)                        \
8325     {                                   \
8326       remaining--;                      \
8327       (OP) = word >> 24;                \
8328       word <<= 8;                       \
8329     }                                   \
8330   else                                  \
8331     {                                   \
8332       printf (_("[Truncated opcode]\n"));       \
8333       return FALSE;                     \
8334     }                                   \
8335   printf ("0x%02x ", OP)
8336
8337 static bfd_boolean
8338 decode_arm_unwind_bytecode (struct arm_unw_aux_info *  aux,
8339                             unsigned int               word,
8340                             unsigned int               remaining,
8341                             unsigned int               more_words,
8342                             bfd_vma                    data_offset,
8343                             Elf_Internal_Shdr *        data_sec,
8344                             struct arm_section *       data_arm_sec)
8345 {
8346   struct absaddr addr;
8347   bfd_boolean res = TRUE;
8348
8349   /* Decode the unwinding instructions.  */
8350   while (1)
8351     {
8352       unsigned int op, op2;
8353
8354       ADVANCE;
8355       if (remaining == 0)
8356         break;
8357       remaining--;
8358       op = word >> 24;
8359       word <<= 8;
8360
8361       printf ("  0x%02x ", op);
8362
8363       if ((op & 0xc0) == 0x00)
8364         {
8365           int offset = ((op & 0x3f) << 2) + 4;
8366
8367           printf ("     vsp = vsp + %d", offset);
8368         }
8369       else if ((op & 0xc0) == 0x40)
8370         {
8371           int offset = ((op & 0x3f) << 2) + 4;
8372
8373           printf ("     vsp = vsp - %d", offset);
8374         }
8375       else if ((op & 0xf0) == 0x80)
8376         {
8377           GET_OP (op2);
8378           if (op == 0x80 && op2 == 0)
8379             printf (_("Refuse to unwind"));
8380           else
8381             {
8382               unsigned int mask = ((op & 0x0f) << 8) | op2;
8383               bfd_boolean first = TRUE;
8384               int i;
8385
8386               printf ("pop {");
8387               for (i = 0; i < 12; i++)
8388                 if (mask & (1 << i))
8389                   {
8390                     if (first)
8391                       first = FALSE;
8392                     else
8393                       printf (", ");
8394                     printf ("r%d", 4 + i);
8395                   }
8396               printf ("}");
8397             }
8398         }
8399       else if ((op & 0xf0) == 0x90)
8400         {
8401           if (op == 0x9d || op == 0x9f)
8402             printf (_("     [Reserved]"));
8403           else
8404             printf ("     vsp = r%d", op & 0x0f);
8405         }
8406       else if ((op & 0xf0) == 0xa0)
8407         {
8408           int end = 4 + (op & 0x07);
8409           bfd_boolean first = TRUE;
8410           int i;
8411
8412           printf ("     pop {");
8413           for (i = 4; i <= end; i++)
8414             {
8415               if (first)
8416                 first = FALSE;
8417               else
8418                 printf (", ");
8419               printf ("r%d", i);
8420             }
8421           if (op & 0x08)
8422             {
8423               if (!first)
8424                 printf (", ");
8425               printf ("r14");
8426             }
8427           printf ("}");
8428         }
8429       else if (op == 0xb0)
8430         printf (_("     finish"));
8431       else if (op == 0xb1)
8432         {
8433           GET_OP (op2);
8434           if (op2 == 0 || (op2 & 0xf0) != 0)
8435             printf (_("[Spare]"));
8436           else
8437             {
8438               unsigned int mask = op2 & 0x0f;
8439               bfd_boolean first = TRUE;
8440               int i;
8441
8442               printf ("pop {");
8443               for (i = 0; i < 12; i++)
8444                 if (mask & (1 << i))
8445                   {
8446                     if (first)
8447                       first = FALSE;
8448                     else
8449                       printf (", ");
8450                     printf ("r%d", i);
8451                   }
8452               printf ("}");
8453             }
8454         }
8455       else if (op == 0xb2)
8456         {
8457           unsigned char buf[9];
8458           unsigned int i, len;
8459           unsigned long offset;
8460
8461           for (i = 0; i < sizeof (buf); i++)
8462             {
8463               GET_OP (buf[i]);
8464               if ((buf[i] & 0x80) == 0)
8465                 break;
8466             }
8467           if (i == sizeof (buf))
8468             {
8469               error (_("corrupt change to vsp"));
8470               res = FALSE;
8471             }
8472           else
8473             {
8474               offset = read_uleb128 (buf, &len, buf + i + 1);
8475               assert (len == i + 1);
8476               offset = offset * 4 + 0x204;
8477               printf ("vsp = vsp + %ld", offset);
8478             }
8479         }
8480       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8481         {
8482           unsigned int first, last;
8483
8484           GET_OP (op2);
8485           first = op2 >> 4;
8486           last = op2 & 0x0f;
8487           if (op == 0xc8)
8488             first = first + 16;
8489           printf ("pop {D%d", first);
8490           if (last)
8491             printf ("-D%d", first + last);
8492           printf ("}");
8493         }
8494       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8495         {
8496           unsigned int count = op & 0x07;
8497
8498           printf ("pop {D8");
8499           if (count)
8500             printf ("-D%d", 8 + count);
8501           printf ("}");
8502         }
8503       else if (op >= 0xc0 && op <= 0xc5)
8504         {
8505           unsigned int count = op & 0x07;
8506
8507           printf ("     pop {wR10");
8508           if (count)
8509             printf ("-wR%d", 10 + count);
8510           printf ("}");
8511         }
8512       else if (op == 0xc6)
8513         {
8514           unsigned int first, last;
8515
8516           GET_OP (op2);
8517           first = op2 >> 4;
8518           last = op2 & 0x0f;
8519           printf ("pop {wR%d", first);
8520           if (last)
8521             printf ("-wR%d", first + last);
8522           printf ("}");
8523         }
8524       else if (op == 0xc7)
8525         {
8526           GET_OP (op2);
8527           if (op2 == 0 || (op2 & 0xf0) != 0)
8528             printf (_("[Spare]"));
8529           else
8530             {
8531               unsigned int mask = op2 & 0x0f;
8532               bfd_boolean first = TRUE;
8533               int i;
8534
8535               printf ("pop {");
8536               for (i = 0; i < 4; i++)
8537                 if (mask & (1 << i))
8538                   {
8539                     if (first)
8540                       first = FALSE;
8541                     else
8542                       printf (", ");
8543                     printf ("wCGR%d", i);
8544                   }
8545               printf ("}");
8546             }
8547         }
8548       else
8549         {
8550           printf (_("     [unsupported opcode]"));
8551           res = FALSE;
8552         }
8553
8554       printf ("\n");
8555     }
8556
8557   return res;
8558 }
8559
8560 static bfd_boolean
8561 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *  aux,
8562                               unsigned int               word,
8563                               unsigned int               remaining,
8564                               unsigned int               more_words,
8565                               bfd_vma                    data_offset,
8566                               Elf_Internal_Shdr *        data_sec,
8567                               struct arm_section *       data_arm_sec)
8568 {
8569   struct absaddr addr;
8570
8571   /* Decode the unwinding instructions.  */
8572   while (1)
8573     {
8574       unsigned int op, op2;
8575
8576       ADVANCE;
8577       if (remaining == 0)
8578         break;
8579       remaining--;
8580       op = word >> 24;
8581       word <<= 8;
8582
8583       printf ("  0x%02x ", op);
8584
8585       if ((op & 0xc0) == 0x00)
8586         {
8587           int offset = ((op & 0x3f) << 3) + 8;
8588           printf ("     sp = sp + %d", offset);
8589         }
8590       else if ((op & 0xc0) == 0x80)
8591         {
8592           GET_OP (op2);
8593           if (op == 0x80 && op2 == 0)
8594             printf (_("Refuse to unwind"));
8595           else
8596             {
8597               unsigned int mask = ((op & 0x1f) << 8) | op2;
8598               if (op & 0x20)
8599                 printf ("pop compact {");
8600               else
8601                 printf ("pop {");
8602
8603               decode_tic6x_unwind_regmask (mask);
8604               printf("}");
8605             }
8606         }
8607       else if ((op & 0xf0) == 0xc0)
8608         {
8609           unsigned int reg;
8610           unsigned int nregs;
8611           unsigned int i;
8612           const char *name;
8613           struct
8614           {
8615             unsigned int offset;
8616             unsigned int reg;
8617           } regpos[16];
8618
8619           /* Scan entire instruction first so that GET_OP output is not
8620              interleaved with disassembly.  */
8621           nregs = 0;
8622           for (i = 0; nregs < (op & 0xf); i++)
8623             {
8624               GET_OP (op2);
8625               reg = op2 >> 4;
8626               if (reg != 0xf)
8627                 {
8628                   regpos[nregs].offset = i * 2;
8629                   regpos[nregs].reg = reg;
8630                   nregs++;
8631                 }
8632
8633               reg = op2 & 0xf;
8634               if (reg != 0xf)
8635                 {
8636                   regpos[nregs].offset = i * 2 + 1;
8637                   regpos[nregs].reg = reg;
8638                   nregs++;
8639                 }
8640             }
8641
8642           printf (_("pop frame {"));
8643           reg = nregs - 1;
8644           for (i = i * 2; i > 0; i--)
8645             {
8646               if (regpos[reg].offset == i - 1)
8647                 {
8648                   name = tic6x_unwind_regnames[regpos[reg].reg];
8649                   if (reg > 0)
8650                     reg--;
8651                 }
8652               else
8653                 name = _("[pad]");
8654
8655               fputs (name, stdout);
8656               if (i > 1)
8657                 printf (", ");
8658             }
8659
8660           printf ("}");
8661         }
8662       else if (op == 0xd0)
8663         printf ("     MOV FP, SP");
8664       else if (op == 0xd1)
8665         printf ("     __c6xabi_pop_rts");
8666       else if (op == 0xd2)
8667         {
8668           unsigned char buf[9];
8669           unsigned int i, len;
8670           unsigned long offset;
8671
8672           for (i = 0; i < sizeof (buf); i++)
8673             {
8674               GET_OP (buf[i]);
8675               if ((buf[i] & 0x80) == 0)
8676                 break;
8677             }
8678           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8679           if (i == sizeof (buf))
8680             {
8681               warn (_("Corrupt stack pointer adjustment detected\n"));
8682               return FALSE;
8683             }
8684
8685           offset = read_uleb128 (buf, &len, buf + i + 1);
8686           assert (len == i + 1);
8687           offset = offset * 8 + 0x408;
8688           printf (_("sp = sp + %ld"), offset);
8689         }
8690       else if ((op & 0xf0) == 0xe0)
8691         {
8692           if ((op & 0x0f) == 7)
8693             printf ("     RETURN");
8694           else
8695             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8696         }
8697       else
8698         {
8699           printf (_("     [unsupported opcode]"));
8700         }
8701       putchar ('\n');
8702     }
8703
8704   return TRUE;
8705 }
8706
8707 static bfd_vma
8708 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8709 {
8710   bfd_vma offset;
8711
8712   offset = word & 0x7fffffff;
8713   if (offset & 0x40000000)
8714     offset |= ~ (bfd_vma) 0x7fffffff;
8715
8716   if (elf_header.e_machine == EM_TI_C6000)
8717     offset <<= 1;
8718
8719   return offset + where;
8720 }
8721
8722 static bfd_boolean
8723 decode_arm_unwind (struct arm_unw_aux_info *  aux,
8724                    unsigned int               word,
8725                    unsigned int               remaining,
8726                    bfd_vma                    data_offset,
8727                    Elf_Internal_Shdr *        data_sec,
8728                    struct arm_section *       data_arm_sec)
8729 {
8730   int per_index;
8731   unsigned int more_words = 0;
8732   struct absaddr addr;
8733   bfd_vma sym_name = (bfd_vma) -1;
8734   bfd_boolean res = FALSE;
8735
8736   if (remaining == 0)
8737     {
8738       /* Fetch the first word.
8739          Note - when decoding an object file the address extracted
8740          here will always be 0.  So we also pass in the sym_name
8741          parameter so that we can find the symbol associated with
8742          the personality routine.  */
8743       if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8744                                      & word, & addr, & sym_name))
8745         return FALSE;
8746
8747       remaining = 4;
8748     }
8749
8750   if ((word & 0x80000000) == 0)
8751     {
8752       /* Expand prel31 for personality routine.  */
8753       bfd_vma fn;
8754       const char *procname;
8755
8756       fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8757       printf (_("  Personality routine: "));
8758       if (fn == 0
8759           && addr.section == SHN_UNDEF && addr.offset == 0
8760           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8761         {
8762           procname = aux->strtab + sym_name;
8763           print_vma (fn, PREFIX_HEX);
8764           if (procname)
8765             {
8766               fputs (" <", stdout);
8767               fputs (procname, stdout);
8768               fputc ('>', stdout);
8769             }
8770         }
8771       else
8772         procname = arm_print_vma_and_name (aux, fn, addr);
8773       fputc ('\n', stdout);
8774
8775       /* The GCC personality routines use the standard compact
8776          encoding, starting with one byte giving the number of
8777          words.  */
8778       if (procname != NULL
8779           && (const_strneq (procname, "__gcc_personality_v0")
8780               || const_strneq (procname, "__gxx_personality_v0")
8781               || const_strneq (procname, "__gcj_personality_v0")
8782               || const_strneq (procname, "__gnu_objc_personality_v0")))
8783         {
8784           remaining = 0;
8785           more_words = 1;
8786           ADVANCE;
8787           if (!remaining)
8788             {
8789               printf (_("  [Truncated data]\n"));
8790               return FALSE;
8791             }
8792           more_words = word >> 24;
8793           word <<= 8;
8794           remaining--;
8795           per_index = -1;
8796         }
8797       else
8798         return TRUE;
8799     }
8800   else
8801     {
8802       /* ARM EHABI Section 6.3:
8803
8804          An exception-handling table entry for the compact model looks like:
8805
8806            31 30-28 27-24 23-0
8807            -- ----- ----- ----
8808             1   0   index Data for personalityRoutine[index]    */
8809
8810       if (elf_header.e_machine == EM_ARM
8811           && (word & 0x70000000))
8812         {
8813           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8814           res = FALSE;
8815         }
8816
8817       per_index = (word >> 24) & 0x7f;
8818       printf (_("  Compact model index: %d\n"), per_index);
8819       if (per_index == 0)
8820         {
8821           more_words = 0;
8822           word <<= 8;
8823           remaining--;
8824         }
8825       else if (per_index < 3)
8826         {
8827           more_words = (word >> 16) & 0xff;
8828           word <<= 16;
8829           remaining -= 2;
8830         }
8831     }
8832
8833   switch (elf_header.e_machine)
8834     {
8835     case EM_ARM:
8836       if (per_index < 3)
8837         {
8838           if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8839                                             data_offset, data_sec, data_arm_sec))
8840             res = FALSE;
8841         }
8842       else
8843         {
8844           warn (_("Unknown ARM compact model index encountered\n"));
8845           printf (_("  [reserved]\n"));
8846           res = FALSE;
8847         }
8848       break;
8849
8850     case EM_TI_C6000:
8851       if (per_index < 3)
8852         {
8853           if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8854                                               data_offset, data_sec, data_arm_sec))
8855             res = FALSE;
8856         }
8857       else if (per_index < 5)
8858         {
8859           if (((word >> 17) & 0x7f) == 0x7f)
8860             printf (_("  Restore stack from frame pointer\n"));
8861           else
8862             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8863           printf (_("  Registers restored: "));
8864           if (per_index == 4)
8865             printf (" (compact) ");
8866           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8867           putchar ('\n');
8868           printf (_("  Return register: %s\n"),
8869                   tic6x_unwind_regnames[word & 0xf]);
8870         }
8871       else
8872         printf (_("  [reserved (%d)]\n"), per_index);
8873       break;
8874
8875     default:
8876       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8877              elf_header.e_machine);
8878       res = FALSE;
8879     }
8880
8881   /* Decode the descriptors.  Not implemented.  */
8882
8883   return res;
8884 }
8885
8886 static bfd_boolean
8887 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8888 {
8889   struct arm_section exidx_arm_sec, extab_arm_sec;
8890   unsigned int i, exidx_len;
8891   unsigned long j, nfuns;
8892   bfd_boolean res = TRUE;
8893
8894   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8895   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8896   exidx_len = exidx_sec->sh_size / 8;
8897
8898   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8899   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8900     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8901       aux->funtab[nfuns++] = aux->symtab[j];
8902   aux->nfuns = nfuns;
8903   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8904
8905   for (i = 0; i < exidx_len; i++)
8906     {
8907       unsigned int exidx_fn, exidx_entry;
8908       struct absaddr fn_addr, entry_addr;
8909       bfd_vma fn;
8910
8911       fputc ('\n', stdout);
8912
8913       if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8914                                      8 * i, & exidx_fn, & fn_addr, NULL)
8915           || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8916                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8917         {
8918           free (aux->funtab);
8919           arm_free_section (& exidx_arm_sec);
8920           arm_free_section (& extab_arm_sec);
8921           return FALSE;
8922         }
8923
8924       /* ARM EHABI, Section 5:
8925          An index table entry consists of 2 words.
8926          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8927       if (exidx_fn & 0x80000000)
8928         {
8929           warn (_("corrupt index table entry: %x\n"), exidx_fn);
8930           res = FALSE;
8931         }
8932
8933       fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8934
8935       arm_print_vma_and_name (aux, fn, fn_addr);
8936       fputs (": ", stdout);
8937
8938       if (exidx_entry == 1)
8939         {
8940           print_vma (exidx_entry, PREFIX_HEX);
8941           fputs (" [cantunwind]\n", stdout);
8942         }
8943       else if (exidx_entry & 0x80000000)
8944         {
8945           print_vma (exidx_entry, PREFIX_HEX);
8946           fputc ('\n', stdout);
8947           decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8948         }
8949       else
8950         {
8951           bfd_vma table, table_offset = 0;
8952           Elf_Internal_Shdr *table_sec;
8953
8954           fputs ("@", stdout);
8955           table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8956           print_vma (table, PREFIX_HEX);
8957           printf ("\n");
8958
8959           /* Locate the matching .ARM.extab.  */
8960           if (entry_addr.section != SHN_UNDEF
8961               && entry_addr.section < elf_header.e_shnum)
8962             {
8963               table_sec = section_headers + entry_addr.section;
8964               table_offset = entry_addr.offset;
8965               /* PR 18879 */
8966               if (table_offset > table_sec->sh_size
8967                   || ((bfd_signed_vma) table_offset) < 0)
8968                 {
8969                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8970                         (unsigned long) table_offset,
8971                         printable_section_name (table_sec));
8972                   res = FALSE;
8973                   continue;
8974                 }
8975             }
8976           else
8977             {
8978               table_sec = find_section_by_address (table);
8979               if (table_sec != NULL)
8980                 table_offset = table - table_sec->sh_addr;
8981             }
8982
8983           if (table_sec == NULL)
8984             {
8985               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8986                     (unsigned long) table);
8987               res = FALSE;
8988               continue;
8989             }
8990
8991           if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8992                                    &extab_arm_sec))
8993             res = FALSE;
8994         }
8995     }
8996
8997   printf ("\n");
8998
8999   free (aux->funtab);
9000   arm_free_section (&exidx_arm_sec);
9001   arm_free_section (&extab_arm_sec);
9002
9003   return res;
9004 }
9005
9006 /* Used for both ARM and C6X unwinding tables.  */
9007
9008 static bfd_boolean
9009 arm_process_unwind (FILE *file)
9010 {
9011   struct arm_unw_aux_info aux;
9012   Elf_Internal_Shdr *unwsec = NULL;
9013   Elf_Internal_Shdr *strsec;
9014   Elf_Internal_Shdr *sec;
9015   unsigned long i;
9016   unsigned int sec_type;
9017   bfd_boolean res = TRUE;
9018
9019   switch (elf_header.e_machine)
9020     {
9021     case EM_ARM:
9022       sec_type = SHT_ARM_EXIDX;
9023       break;
9024
9025     case EM_TI_C6000:
9026       sec_type = SHT_C6000_UNWIND;
9027       break;
9028
9029     default:
9030       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9031              elf_header.e_machine);
9032       return FALSE;
9033     }
9034
9035   if (string_table == NULL)
9036     return FALSE;
9037
9038   memset (& aux, 0, sizeof (aux));
9039   aux.file = file;
9040
9041   for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9042     {
9043       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9044         {
9045           aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9046
9047           strsec = section_headers + sec->sh_link;
9048
9049           /* PR binutils/17531 file: 011-12666-0.004.  */
9050           if (aux.strtab != NULL)
9051             {
9052               error (_("Multiple string tables found in file.\n"));
9053               free (aux.strtab);
9054               res = FALSE;
9055             }
9056           aux.strtab = get_data (NULL, file, strsec->sh_offset,
9057                                  1, strsec->sh_size, _("string table"));
9058           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9059         }
9060       else if (sec->sh_type == sec_type)
9061         unwsec = sec;
9062     }
9063
9064   if (unwsec == NULL)
9065     printf (_("\nThere are no unwind sections in this file.\n"));
9066   else
9067     for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9068       {
9069         if (sec->sh_type == sec_type)
9070           {
9071             printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9072                     printable_section_name (sec),
9073                     (unsigned long) sec->sh_offset,
9074                     (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9075
9076             if (! dump_arm_unwind (&aux, sec))
9077               res = FALSE;
9078           }
9079       }
9080
9081   if (aux.symtab)
9082     free (aux.symtab);
9083   if (aux.strtab)
9084     free ((char *) aux.strtab);
9085
9086   return res;
9087 }
9088
9089 static bfd_boolean
9090 process_unwind (FILE * file)
9091 {
9092   struct unwind_handler
9093   {
9094     unsigned int machtype;
9095     bfd_boolean (* handler)(FILE *);
9096   } handlers[] =
9097   {
9098     { EM_ARM, arm_process_unwind },
9099     { EM_IA_64, ia64_process_unwind },
9100     { EM_PARISC, hppa_process_unwind },
9101     { EM_TI_C6000, arm_process_unwind },
9102     { 0, NULL }
9103   };
9104   int i;
9105
9106   if (!do_unwind)
9107     return TRUE;
9108
9109   for (i = 0; handlers[i].handler != NULL; i++)
9110     if (elf_header.e_machine == handlers[i].machtype)
9111       return handlers[i].handler (file);
9112
9113   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9114           get_machine_name (elf_header.e_machine));
9115   return TRUE;
9116 }
9117
9118 static void
9119 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9120 {
9121   switch (entry->d_tag)
9122     {
9123     case DT_MIPS_FLAGS:
9124       if (entry->d_un.d_val == 0)
9125         printf (_("NONE"));
9126       else
9127         {
9128           static const char * opts[] =
9129           {
9130             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9131             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9132             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9133             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9134             "RLD_ORDER_SAFE"
9135           };
9136           unsigned int cnt;
9137           bfd_boolean first = TRUE;
9138
9139           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9140             if (entry->d_un.d_val & (1 << cnt))
9141               {
9142                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9143                 first = FALSE;
9144               }
9145         }
9146       break;
9147
9148     case DT_MIPS_IVERSION:
9149       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9150         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9151       else
9152         {
9153           char buf[40];
9154           sprintf_vma (buf, entry->d_un.d_ptr);
9155           /* Note: coded this way so that there is a single string for translation.  */
9156           printf (_("<corrupt: %s>"), buf);
9157         }
9158       break;
9159
9160     case DT_MIPS_TIME_STAMP:
9161       {
9162         char timebuf[128];
9163         struct tm * tmp;
9164         time_t atime = entry->d_un.d_val;
9165
9166         tmp = gmtime (&atime);
9167         /* PR 17531: file: 6accc532.  */
9168         if (tmp == NULL)
9169           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9170         else
9171           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9172                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9173                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9174         printf (_("Time Stamp: %s"), timebuf);
9175       }
9176       break;
9177
9178     case DT_MIPS_RLD_VERSION:
9179     case DT_MIPS_LOCAL_GOTNO:
9180     case DT_MIPS_CONFLICTNO:
9181     case DT_MIPS_LIBLISTNO:
9182     case DT_MIPS_SYMTABNO:
9183     case DT_MIPS_UNREFEXTNO:
9184     case DT_MIPS_HIPAGENO:
9185     case DT_MIPS_DELTA_CLASS_NO:
9186     case DT_MIPS_DELTA_INSTANCE_NO:
9187     case DT_MIPS_DELTA_RELOC_NO:
9188     case DT_MIPS_DELTA_SYM_NO:
9189     case DT_MIPS_DELTA_CLASSSYM_NO:
9190     case DT_MIPS_COMPACT_SIZE:
9191       print_vma (entry->d_un.d_val, DEC);
9192       break;
9193
9194     default:
9195       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9196     }
9197     putchar ('\n');
9198 }
9199
9200 static void
9201 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9202 {
9203   switch (entry->d_tag)
9204     {
9205     case DT_HP_DLD_FLAGS:
9206       {
9207         static struct
9208         {
9209           long int bit;
9210           const char * str;
9211         }
9212         flags[] =
9213         {
9214           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9215           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9216           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9217           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9218           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9219           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9220           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9221           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9222           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9223           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9224           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9225           { DT_HP_GST, "HP_GST" },
9226           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9227           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9228           { DT_HP_NODELETE, "HP_NODELETE" },
9229           { DT_HP_GROUP, "HP_GROUP" },
9230           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9231         };
9232         bfd_boolean first = TRUE;
9233         size_t cnt;
9234         bfd_vma val = entry->d_un.d_val;
9235
9236         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9237           if (val & flags[cnt].bit)
9238             {
9239               if (! first)
9240                 putchar (' ');
9241               fputs (flags[cnt].str, stdout);
9242               first = FALSE;
9243               val ^= flags[cnt].bit;
9244             }
9245
9246         if (val != 0 || first)
9247           {
9248             if (! first)
9249               putchar (' ');
9250             print_vma (val, HEX);
9251           }
9252       }
9253       break;
9254
9255     default:
9256       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9257       break;
9258     }
9259   putchar ('\n');
9260 }
9261
9262 #ifdef BFD64
9263
9264 /* VMS vs Unix time offset and factor.  */
9265
9266 #define VMS_EPOCH_OFFSET 35067168000000000LL
9267 #define VMS_GRANULARITY_FACTOR 10000000
9268
9269 /* Display a VMS time in a human readable format.  */
9270
9271 static void
9272 print_vms_time (bfd_int64_t vmstime)
9273 {
9274   struct tm *tm;
9275   time_t unxtime;
9276
9277   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9278   tm = gmtime (&unxtime);
9279   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9280           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9281           tm->tm_hour, tm->tm_min, tm->tm_sec);
9282 }
9283 #endif /* BFD64 */
9284
9285 static void
9286 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9287 {
9288   switch (entry->d_tag)
9289     {
9290     case DT_IA_64_PLT_RESERVE:
9291       /* First 3 slots reserved.  */
9292       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9293       printf (" -- ");
9294       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9295       break;
9296
9297     case DT_IA_64_VMS_LINKTIME:
9298 #ifdef BFD64
9299       print_vms_time (entry->d_un.d_val);
9300 #endif
9301       break;
9302
9303     case DT_IA_64_VMS_LNKFLAGS:
9304       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9305       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9306         printf (" CALL_DEBUG");
9307       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9308         printf (" NOP0BUFS");
9309       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9310         printf (" P0IMAGE");
9311       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9312         printf (" MKTHREADS");
9313       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9314         printf (" UPCALLS");
9315       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9316         printf (" IMGSTA");
9317       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9318         printf (" INITIALIZE");
9319       if (entry->d_un.d_val & VMS_LF_MAIN)
9320         printf (" MAIN");
9321       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9322         printf (" EXE_INIT");
9323       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9324         printf (" TBK_IN_IMG");
9325       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9326         printf (" DBG_IN_IMG");
9327       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9328         printf (" TBK_IN_DSF");
9329       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9330         printf (" DBG_IN_DSF");
9331       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9332         printf (" SIGNATURES");
9333       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9334         printf (" REL_SEG_OFF");
9335       break;
9336
9337     default:
9338       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9339       break;
9340     }
9341   putchar ('\n');
9342 }
9343
9344 static bfd_boolean
9345 get_32bit_dynamic_section (FILE * file)
9346 {
9347   Elf32_External_Dyn * edyn;
9348   Elf32_External_Dyn * ext;
9349   Elf_Internal_Dyn * entry;
9350
9351   edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9352                                           dynamic_size, _("dynamic section"));
9353   if (!edyn)
9354     return FALSE;
9355
9356   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9357      might not have the luxury of section headers.  Look for the DT_NULL
9358      terminator to determine the number of entries.  */
9359   for (ext = edyn, dynamic_nent = 0;
9360        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9361        ext++)
9362     {
9363       dynamic_nent++;
9364       if (BYTE_GET (ext->d_tag) == DT_NULL)
9365         break;
9366     }
9367
9368   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9369                                                   sizeof (* entry));
9370   if (dynamic_section == NULL)
9371     {
9372       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9373              (unsigned long) dynamic_nent);
9374       free (edyn);
9375       return FALSE;
9376     }
9377
9378   for (ext = edyn, entry = dynamic_section;
9379        entry < dynamic_section + dynamic_nent;
9380        ext++, entry++)
9381     {
9382       entry->d_tag      = BYTE_GET (ext->d_tag);
9383       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9384     }
9385
9386   free (edyn);
9387
9388   return TRUE;
9389 }
9390
9391 static bfd_boolean
9392 get_64bit_dynamic_section (FILE * file)
9393 {
9394   Elf64_External_Dyn * edyn;
9395   Elf64_External_Dyn * ext;
9396   Elf_Internal_Dyn * entry;
9397
9398   /* Read in the data.  */
9399   edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9400                                           dynamic_size, _("dynamic section"));
9401   if (!edyn)
9402     return FALSE;
9403
9404   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9405      might not have the luxury of section headers.  Look for the DT_NULL
9406      terminator to determine the number of entries.  */
9407   for (ext = edyn, dynamic_nent = 0;
9408        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9409        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9410        ext++)
9411     {
9412       dynamic_nent++;
9413       if (BYTE_GET (ext->d_tag) == DT_NULL)
9414         break;
9415     }
9416
9417   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9418                                                   sizeof (* entry));
9419   if (dynamic_section == NULL)
9420     {
9421       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9422              (unsigned long) dynamic_nent);
9423       free (edyn);
9424       return FALSE;
9425     }
9426
9427   /* Convert from external to internal formats.  */
9428   for (ext = edyn, entry = dynamic_section;
9429        entry < dynamic_section + dynamic_nent;
9430        ext++, entry++)
9431     {
9432       entry->d_tag      = BYTE_GET (ext->d_tag);
9433       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9434     }
9435
9436   free (edyn);
9437
9438   return TRUE;
9439 }
9440
9441 static void
9442 print_dynamic_flags (bfd_vma flags)
9443 {
9444   bfd_boolean first = TRUE;
9445
9446   while (flags)
9447     {
9448       bfd_vma flag;
9449
9450       flag = flags & - flags;
9451       flags &= ~ flag;
9452
9453       if (first)
9454         first = FALSE;
9455       else
9456         putc (' ', stdout);
9457
9458       switch (flag)
9459         {
9460         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9461         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9462         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9463         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9464         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9465         default:                fputs (_("unknown"), stdout); break;
9466         }
9467     }
9468   puts ("");
9469 }
9470
9471 /* Parse and display the contents of the dynamic section.  */
9472
9473 static bfd_boolean
9474 process_dynamic_section (FILE * file)
9475 {
9476   Elf_Internal_Dyn * entry;
9477
9478   if (dynamic_size == 0)
9479     {
9480       if (do_dynamic)
9481         printf (_("\nThere is no dynamic section in this file.\n"));
9482
9483       return TRUE;
9484     }
9485
9486   if (is_32bit_elf)
9487     {
9488       if (! get_32bit_dynamic_section (file))
9489         return FALSE;
9490     }
9491   else
9492     {
9493       if (! get_64bit_dynamic_section (file))
9494         return FALSE;
9495     }
9496
9497   /* Find the appropriate symbol table.  */
9498   if (dynamic_symbols == NULL)
9499     {
9500       for (entry = dynamic_section;
9501            entry < dynamic_section + dynamic_nent;
9502            ++entry)
9503         {
9504           Elf_Internal_Shdr section;
9505
9506           if (entry->d_tag != DT_SYMTAB)
9507             continue;
9508
9509           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9510
9511           /* Since we do not know how big the symbol table is,
9512              we default to reading in the entire file (!) and
9513              processing that.  This is overkill, I know, but it
9514              should work.  */
9515           section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9516           if ((bfd_size_type) section.sh_offset > current_file_size)
9517             {
9518               /* See PR 21379 for a reproducer.  */
9519               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9520               return FALSE;
9521             }
9522
9523           if (archive_file_offset != 0)
9524             section.sh_size = archive_file_size - section.sh_offset;
9525           else
9526             {
9527               if (fseek (file, 0, SEEK_END))
9528                 error (_("Unable to seek to end of file!\n"));
9529
9530               section.sh_size = ftell (file) - section.sh_offset;
9531             }
9532
9533           if (is_32bit_elf)
9534             section.sh_entsize = sizeof (Elf32_External_Sym);
9535           else
9536             section.sh_entsize = sizeof (Elf64_External_Sym);
9537           section.sh_name = string_table_length;
9538
9539           dynamic_symbols = GET_ELF_SYMBOLS (file, &section, & num_dynamic_syms);
9540           if (num_dynamic_syms < 1)
9541             {
9542               error (_("Unable to determine the number of symbols to load\n"));
9543               continue;
9544             }
9545         }
9546     }
9547
9548   /* Similarly find a string table.  */
9549   if (dynamic_strings == NULL)
9550     {
9551       for (entry = dynamic_section;
9552            entry < dynamic_section + dynamic_nent;
9553            ++entry)
9554         {
9555           unsigned long offset;
9556           long str_tab_len;
9557
9558           if (entry->d_tag != DT_STRTAB)
9559             continue;
9560
9561           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9562
9563           /* Since we do not know how big the string table is,
9564              we default to reading in the entire file (!) and
9565              processing that.  This is overkill, I know, but it
9566              should work.  */
9567
9568           offset = offset_from_vma (file, entry->d_un.d_val, 0);
9569
9570           if (archive_file_offset != 0)
9571             str_tab_len = archive_file_size - offset;
9572           else
9573             {
9574               if (fseek (file, 0, SEEK_END))
9575                 error (_("Unable to seek to end of file\n"));
9576               str_tab_len = ftell (file) - offset;
9577             }
9578
9579           if (str_tab_len < 1)
9580             {
9581               error
9582                 (_("Unable to determine the length of the dynamic string table\n"));
9583               continue;
9584             }
9585
9586           dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9587                                                str_tab_len,
9588                                                _("dynamic string table"));
9589           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9590           break;
9591         }
9592     }
9593
9594   /* And find the syminfo section if available.  */
9595   if (dynamic_syminfo == NULL)
9596     {
9597       unsigned long syminsz = 0;
9598
9599       for (entry = dynamic_section;
9600            entry < dynamic_section + dynamic_nent;
9601            ++entry)
9602         {
9603           if (entry->d_tag == DT_SYMINENT)
9604             {
9605               /* Note: these braces are necessary to avoid a syntax
9606                  error from the SunOS4 C compiler.  */
9607               /* PR binutils/17531: A corrupt file can trigger this test.
9608                  So do not use an assert, instead generate an error message.  */
9609               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9610                 error (_("Bad value (%d) for SYMINENT entry\n"),
9611                        (int) entry->d_un.d_val);
9612             }
9613           else if (entry->d_tag == DT_SYMINSZ)
9614             syminsz = entry->d_un.d_val;
9615           else if (entry->d_tag == DT_SYMINFO)
9616             dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9617                                                       syminsz);
9618         }
9619
9620       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9621         {
9622           Elf_External_Syminfo * extsyminfo;
9623           Elf_External_Syminfo * extsym;
9624           Elf_Internal_Syminfo * syminfo;
9625
9626           /* There is a syminfo section.  Read the data.  */
9627           extsyminfo = (Elf_External_Syminfo *)
9628               get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9629                         _("symbol information"));
9630           if (!extsyminfo)
9631             return FALSE;
9632
9633           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9634           if (dynamic_syminfo == NULL)
9635             {
9636               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9637                      (unsigned long) syminsz);
9638               return FALSE;
9639             }
9640
9641           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9642           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9643                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9644                ++syminfo, ++extsym)
9645             {
9646               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9647               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9648             }
9649
9650           free (extsyminfo);
9651         }
9652     }
9653
9654   if (do_dynamic && dynamic_addr)
9655     printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9656             dynamic_addr, (unsigned long) dynamic_nent);
9657   if (do_dynamic)
9658     printf (_("  Tag        Type                         Name/Value\n"));
9659
9660   for (entry = dynamic_section;
9661        entry < dynamic_section + dynamic_nent;
9662        entry++)
9663     {
9664       if (do_dynamic)
9665         {
9666           const char * dtype;
9667
9668           putchar (' ');
9669           print_vma (entry->d_tag, FULL_HEX);
9670           dtype = get_dynamic_type (entry->d_tag);
9671           printf (" (%s)%*s", dtype,
9672                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9673         }
9674
9675       switch (entry->d_tag)
9676         {
9677         case DT_FLAGS:
9678           if (do_dynamic)
9679             print_dynamic_flags (entry->d_un.d_val);
9680           break;
9681
9682         case DT_AUXILIARY:
9683         case DT_FILTER:
9684         case DT_CONFIG:
9685         case DT_DEPAUDIT:
9686         case DT_AUDIT:
9687           if (do_dynamic)
9688             {
9689               switch (entry->d_tag)
9690                 {
9691                 case DT_AUXILIARY:
9692                   printf (_("Auxiliary library"));
9693                   break;
9694
9695                 case DT_FILTER:
9696                   printf (_("Filter library"));
9697                   break;
9698
9699                 case DT_CONFIG:
9700                   printf (_("Configuration file"));
9701                   break;
9702
9703                 case DT_DEPAUDIT:
9704                   printf (_("Dependency audit library"));
9705                   break;
9706
9707                 case DT_AUDIT:
9708                   printf (_("Audit library"));
9709                   break;
9710                 }
9711
9712               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9713                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9714               else
9715                 {
9716                   printf (": ");
9717                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9718                   putchar ('\n');
9719                 }
9720             }
9721           break;
9722
9723         case DT_FEATURE:
9724           if (do_dynamic)
9725             {
9726               printf (_("Flags:"));
9727
9728               if (entry->d_un.d_val == 0)
9729                 printf (_(" None\n"));
9730               else
9731                 {
9732                   unsigned long int val = entry->d_un.d_val;
9733
9734                   if (val & DTF_1_PARINIT)
9735                     {
9736                       printf (" PARINIT");
9737                       val ^= DTF_1_PARINIT;
9738                     }
9739                   if (val & DTF_1_CONFEXP)
9740                     {
9741                       printf (" CONFEXP");
9742                       val ^= DTF_1_CONFEXP;
9743                     }
9744                   if (val != 0)
9745                     printf (" %lx", val);
9746                   puts ("");
9747                 }
9748             }
9749           break;
9750
9751         case DT_POSFLAG_1:
9752           if (do_dynamic)
9753             {
9754               printf (_("Flags:"));
9755
9756               if (entry->d_un.d_val == 0)
9757                 printf (_(" None\n"));
9758               else
9759                 {
9760                   unsigned long int val = entry->d_un.d_val;
9761
9762                   if (val & DF_P1_LAZYLOAD)
9763                     {
9764                       printf (" LAZYLOAD");
9765                       val ^= DF_P1_LAZYLOAD;
9766                     }
9767                   if (val & DF_P1_GROUPPERM)
9768                     {
9769                       printf (" GROUPPERM");
9770                       val ^= DF_P1_GROUPPERM;
9771                     }
9772                   if (val != 0)
9773                     printf (" %lx", val);
9774                   puts ("");
9775                 }
9776             }
9777           break;
9778
9779         case DT_FLAGS_1:
9780           if (do_dynamic)
9781             {
9782               printf (_("Flags:"));
9783               if (entry->d_un.d_val == 0)
9784                 printf (_(" None\n"));
9785               else
9786                 {
9787                   unsigned long int val = entry->d_un.d_val;
9788
9789                   if (val & DF_1_NOW)
9790                     {
9791                       printf (" NOW");
9792                       val ^= DF_1_NOW;
9793                     }
9794                   if (val & DF_1_GLOBAL)
9795                     {
9796                       printf (" GLOBAL");
9797                       val ^= DF_1_GLOBAL;
9798                     }
9799                   if (val & DF_1_GROUP)
9800                     {
9801                       printf (" GROUP");
9802                       val ^= DF_1_GROUP;
9803                     }
9804                   if (val & DF_1_NODELETE)
9805                     {
9806                       printf (" NODELETE");
9807                       val ^= DF_1_NODELETE;
9808                     }
9809                   if (val & DF_1_LOADFLTR)
9810                     {
9811                       printf (" LOADFLTR");
9812                       val ^= DF_1_LOADFLTR;
9813                     }
9814                   if (val & DF_1_INITFIRST)
9815                     {
9816                       printf (" INITFIRST");
9817                       val ^= DF_1_INITFIRST;
9818                     }
9819                   if (val & DF_1_NOOPEN)
9820                     {
9821                       printf (" NOOPEN");
9822                       val ^= DF_1_NOOPEN;
9823                     }
9824                   if (val & DF_1_ORIGIN)
9825                     {
9826                       printf (" ORIGIN");
9827                       val ^= DF_1_ORIGIN;
9828                     }
9829                   if (val & DF_1_DIRECT)
9830                     {
9831                       printf (" DIRECT");
9832                       val ^= DF_1_DIRECT;
9833                     }
9834                   if (val & DF_1_TRANS)
9835                     {
9836                       printf (" TRANS");
9837                       val ^= DF_1_TRANS;
9838                     }
9839                   if (val & DF_1_INTERPOSE)
9840                     {
9841                       printf (" INTERPOSE");
9842                       val ^= DF_1_INTERPOSE;
9843                     }
9844                   if (val & DF_1_NODEFLIB)
9845                     {
9846                       printf (" NODEFLIB");
9847                       val ^= DF_1_NODEFLIB;
9848                     }
9849                   if (val & DF_1_NODUMP)
9850                     {
9851                       printf (" NODUMP");
9852                       val ^= DF_1_NODUMP;
9853                     }
9854                   if (val & DF_1_CONFALT)
9855                     {
9856                       printf (" CONFALT");
9857                       val ^= DF_1_CONFALT;
9858                     }
9859                   if (val & DF_1_ENDFILTEE)
9860                     {
9861                       printf (" ENDFILTEE");
9862                       val ^= DF_1_ENDFILTEE;
9863                     }
9864                   if (val & DF_1_DISPRELDNE)
9865                     {
9866                       printf (" DISPRELDNE");
9867                       val ^= DF_1_DISPRELDNE;
9868                     }
9869                   if (val & DF_1_DISPRELPND)
9870                     {
9871                       printf (" DISPRELPND");
9872                       val ^= DF_1_DISPRELPND;
9873                     }
9874                   if (val & DF_1_NODIRECT)
9875                     {
9876                       printf (" NODIRECT");
9877                       val ^= DF_1_NODIRECT;
9878                     }
9879                   if (val & DF_1_IGNMULDEF)
9880                     {
9881                       printf (" IGNMULDEF");
9882                       val ^= DF_1_IGNMULDEF;
9883                     }
9884                   if (val & DF_1_NOKSYMS)
9885                     {
9886                       printf (" NOKSYMS");
9887                       val ^= DF_1_NOKSYMS;
9888                     }
9889                   if (val & DF_1_NOHDR)
9890                     {
9891                       printf (" NOHDR");
9892                       val ^= DF_1_NOHDR;
9893                     }
9894                   if (val & DF_1_EDITED)
9895                     {
9896                       printf (" EDITED");
9897                       val ^= DF_1_EDITED;
9898                     }
9899                   if (val & DF_1_NORELOC)
9900                     {
9901                       printf (" NORELOC");
9902                       val ^= DF_1_NORELOC;
9903                     }
9904                   if (val & DF_1_SYMINTPOSE)
9905                     {
9906                       printf (" SYMINTPOSE");
9907                       val ^= DF_1_SYMINTPOSE;
9908                     }
9909                   if (val & DF_1_GLOBAUDIT)
9910                     {
9911                       printf (" GLOBAUDIT");
9912                       val ^= DF_1_GLOBAUDIT;
9913                     }
9914                   if (val & DF_1_SINGLETON)
9915                     {
9916                       printf (" SINGLETON");
9917                       val ^= DF_1_SINGLETON;
9918                     }
9919                   if (val & DF_1_STUB)
9920                     {
9921                       printf (" STUB");
9922                       val ^= DF_1_STUB;
9923                     }
9924                   if (val & DF_1_PIE)
9925                     {
9926                       printf (" PIE");
9927                       val ^= DF_1_PIE;
9928                     }
9929                   if (val != 0)
9930                     printf (" %lx", val);
9931                   puts ("");
9932                 }
9933             }
9934           break;
9935
9936         case DT_PLTREL:
9937           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9938           if (do_dynamic)
9939             puts (get_dynamic_type (entry->d_un.d_val));
9940           break;
9941
9942         case DT_NULL    :
9943         case DT_NEEDED  :
9944         case DT_PLTGOT  :
9945         case DT_HASH    :
9946         case DT_STRTAB  :
9947         case DT_SYMTAB  :
9948         case DT_RELA    :
9949         case DT_INIT    :
9950         case DT_FINI    :
9951         case DT_SONAME  :
9952         case DT_RPATH   :
9953         case DT_SYMBOLIC:
9954         case DT_REL     :
9955         case DT_DEBUG   :
9956         case DT_TEXTREL :
9957         case DT_JMPREL  :
9958         case DT_RUNPATH :
9959           dynamic_info[entry->d_tag] = entry->d_un.d_val;
9960
9961           if (do_dynamic)
9962             {
9963               char * name;
9964
9965               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9966                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9967               else
9968                 name = NULL;
9969
9970               if (name)
9971                 {
9972                   switch (entry->d_tag)
9973                     {
9974                     case DT_NEEDED:
9975                       printf (_("Shared library: [%s]"), name);
9976
9977                       if (streq (name, program_interpreter))
9978                         printf (_(" program interpreter"));
9979                       break;
9980
9981                     case DT_SONAME:
9982                       printf (_("Library soname: [%s]"), name);
9983                       break;
9984
9985                     case DT_RPATH:
9986                       printf (_("Library rpath: [%s]"), name);
9987                       break;
9988
9989                     case DT_RUNPATH:
9990                       printf (_("Library runpath: [%s]"), name);
9991                       break;
9992
9993                     default:
9994                       print_vma (entry->d_un.d_val, PREFIX_HEX);
9995                       break;
9996                     }
9997                 }
9998               else
9999                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10000
10001               putchar ('\n');
10002             }
10003           break;
10004
10005         case DT_PLTRELSZ:
10006         case DT_RELASZ  :
10007         case DT_STRSZ   :
10008         case DT_RELSZ   :
10009         case DT_RELAENT :
10010         case DT_SYMENT  :
10011         case DT_RELENT  :
10012           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10013           /* Fall through.  */
10014         case DT_PLTPADSZ:
10015         case DT_MOVEENT :
10016         case DT_MOVESZ  :
10017         case DT_INIT_ARRAYSZ:
10018         case DT_FINI_ARRAYSZ:
10019         case DT_GNU_CONFLICTSZ:
10020         case DT_GNU_LIBLISTSZ:
10021           if (do_dynamic)
10022             {
10023               print_vma (entry->d_un.d_val, UNSIGNED);
10024               printf (_(" (bytes)\n"));
10025             }
10026           break;
10027
10028         case DT_VERDEFNUM:
10029         case DT_VERNEEDNUM:
10030         case DT_RELACOUNT:
10031         case DT_RELCOUNT:
10032           if (do_dynamic)
10033             {
10034               print_vma (entry->d_un.d_val, UNSIGNED);
10035               putchar ('\n');
10036             }
10037           break;
10038
10039         case DT_SYMINSZ:
10040         case DT_SYMINENT:
10041         case DT_SYMINFO:
10042         case DT_USED:
10043         case DT_INIT_ARRAY:
10044         case DT_FINI_ARRAY:
10045           if (do_dynamic)
10046             {
10047               if (entry->d_tag == DT_USED
10048                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10049                 {
10050                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10051
10052                   if (*name)
10053                     {
10054                       printf (_("Not needed object: [%s]\n"), name);
10055                       break;
10056                     }
10057                 }
10058
10059               print_vma (entry->d_un.d_val, PREFIX_HEX);
10060               putchar ('\n');
10061             }
10062           break;
10063
10064         case DT_BIND_NOW:
10065           /* The value of this entry is ignored.  */
10066           if (do_dynamic)
10067             putchar ('\n');
10068           break;
10069
10070         case DT_GNU_PRELINKED:
10071           if (do_dynamic)
10072             {
10073               struct tm * tmp;
10074               time_t atime = entry->d_un.d_val;
10075
10076               tmp = gmtime (&atime);
10077               /* PR 17533 file: 041-1244816-0.004.  */
10078               if (tmp == NULL)
10079                 printf (_("<corrupt time val: %lx"),
10080                         (unsigned long) atime);
10081               else
10082                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10083                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10084                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10085
10086             }
10087           break;
10088
10089         case DT_GNU_HASH:
10090           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10091           if (do_dynamic)
10092             {
10093               print_vma (entry->d_un.d_val, PREFIX_HEX);
10094               putchar ('\n');
10095             }
10096           break;
10097
10098         default:
10099           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10100             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10101               entry->d_un.d_val;
10102
10103           if (do_dynamic)
10104             {
10105               switch (elf_header.e_machine)
10106                 {
10107                 case EM_MIPS:
10108                 case EM_MIPS_RS3_LE:
10109                   dynamic_section_mips_val (entry);
10110                   break;
10111                 case EM_PARISC:
10112                   dynamic_section_parisc_val (entry);
10113                   break;
10114                 case EM_IA_64:
10115                   dynamic_section_ia64_val (entry);
10116                   break;
10117                 default:
10118                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10119                   putchar ('\n');
10120                 }
10121             }
10122           break;
10123         }
10124     }
10125
10126   return TRUE;
10127 }
10128
10129 static char *
10130 get_ver_flags (unsigned int flags)
10131 {
10132   static char buff[32];
10133
10134   buff[0] = 0;
10135
10136   if (flags == 0)
10137     return _("none");
10138
10139   if (flags & VER_FLG_BASE)
10140     strcat (buff, "BASE");
10141
10142   if (flags & VER_FLG_WEAK)
10143     {
10144       if (flags & VER_FLG_BASE)
10145         strcat (buff, " | ");
10146
10147       strcat (buff, "WEAK");
10148     }
10149
10150   if (flags & VER_FLG_INFO)
10151     {
10152       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10153         strcat (buff, " | ");
10154
10155       strcat (buff, "INFO");
10156     }
10157
10158   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10159     {
10160       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10161         strcat (buff, " | ");
10162
10163       strcat (buff, _("<unknown>"));
10164     }
10165
10166   return buff;
10167 }
10168
10169 /* Display the contents of the version sections.  */
10170
10171 static bfd_boolean
10172 process_version_sections (FILE * file)
10173 {
10174   Elf_Internal_Shdr * section;
10175   unsigned i;
10176   bfd_boolean found = FALSE;
10177
10178   if (! do_version)
10179     return TRUE;
10180
10181   for (i = 0, section = section_headers;
10182        i < elf_header.e_shnum;
10183        i++, section++)
10184     {
10185       switch (section->sh_type)
10186         {
10187         case SHT_GNU_verdef:
10188           {
10189             Elf_External_Verdef * edefs;
10190             unsigned long idx;
10191             unsigned long cnt;
10192             char * endbuf;
10193
10194             found = TRUE;
10195
10196             printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10197                     printable_section_name (section),
10198                     section->sh_info);
10199
10200             printf (_("  Addr: 0x"));
10201             printf_vma (section->sh_addr);
10202             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10203                     (unsigned long) section->sh_offset, section->sh_link,
10204                     printable_section_name_from_index (section->sh_link));
10205
10206             edefs = (Elf_External_Verdef *)
10207                 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10208                           _("version definition section"));
10209             if (!edefs)
10210               break;
10211             endbuf = (char *) edefs + section->sh_size;
10212
10213             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10214               {
10215                 char * vstart;
10216                 Elf_External_Verdef * edef;
10217                 Elf_Internal_Verdef ent;
10218                 Elf_External_Verdaux * eaux;
10219                 Elf_Internal_Verdaux aux;
10220                 unsigned long isum;
10221                 int j;
10222
10223                 vstart = ((char *) edefs) + idx;
10224                 if (vstart + sizeof (*edef) > endbuf)
10225                   break;
10226
10227                 edef = (Elf_External_Verdef *) vstart;
10228
10229                 ent.vd_version = BYTE_GET (edef->vd_version);
10230                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10231                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10232                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10233                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10234                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10235                 ent.vd_next    = BYTE_GET (edef->vd_next);
10236
10237                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10238                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10239
10240                 printf (_("  Index: %d  Cnt: %d  "),
10241                         ent.vd_ndx, ent.vd_cnt);
10242
10243                 /* Check for overflow.  */
10244                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10245                   break;
10246
10247                 vstart += ent.vd_aux;
10248
10249                 if (vstart + sizeof (*eaux) > endbuf)
10250                   break;
10251                 eaux = (Elf_External_Verdaux *) vstart;
10252
10253                 aux.vda_name = BYTE_GET (eaux->vda_name);
10254                 aux.vda_next = BYTE_GET (eaux->vda_next);
10255
10256                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10257                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10258                 else
10259                   printf (_("Name index: %ld\n"), aux.vda_name);
10260
10261                 isum = idx + ent.vd_aux;
10262
10263                 for (j = 1; j < ent.vd_cnt; j++)
10264                   {
10265                     if (aux.vda_next < sizeof (*eaux)
10266                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10267                       {
10268                         warn (_("Invalid vda_next field of %lx\n"),
10269                               aux.vda_next);
10270                         j = ent.vd_cnt;
10271                         break;
10272                       }
10273                     /* Check for overflow.  */
10274                     if (aux.vda_next > (size_t) (endbuf - vstart))
10275                       break;
10276
10277                     isum   += aux.vda_next;
10278                     vstart += aux.vda_next;
10279
10280                     if (vstart + sizeof (*eaux) > endbuf)
10281                       break;
10282                     eaux = (Elf_External_Verdaux *) vstart;
10283
10284                     aux.vda_name = BYTE_GET (eaux->vda_name);
10285                     aux.vda_next = BYTE_GET (eaux->vda_next);
10286
10287                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10288                       printf (_("  %#06lx: Parent %d: %s\n"),
10289                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10290                     else
10291                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10292                               isum, j, aux.vda_name);
10293                   }
10294
10295                 if (j < ent.vd_cnt)
10296                   printf (_("  Version def aux past end of section\n"));
10297
10298                 /* PR 17531:
10299                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10300                 if (ent.vd_next < sizeof (*edef)
10301                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10302                   {
10303                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10304                     cnt = section->sh_info;
10305                     break;
10306                   }
10307                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10308                   break;
10309
10310                 idx += ent.vd_next;
10311               }
10312
10313             if (cnt < section->sh_info)
10314               printf (_("  Version definition past end of section\n"));
10315
10316             free (edefs);
10317           }
10318           break;
10319
10320         case SHT_GNU_verneed:
10321           {
10322             Elf_External_Verneed * eneed;
10323             unsigned long idx;
10324             unsigned long cnt;
10325             char * endbuf;
10326
10327             found = TRUE;
10328
10329             printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10330                     printable_section_name (section), section->sh_info);
10331
10332             printf (_(" Addr: 0x"));
10333             printf_vma (section->sh_addr);
10334             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10335                     (unsigned long) section->sh_offset, section->sh_link,
10336                     printable_section_name_from_index (section->sh_link));
10337
10338             eneed = (Elf_External_Verneed *) get_data (NULL, file,
10339                                                        section->sh_offset, 1,
10340                                                        section->sh_size,
10341                                                        _("Version Needs section"));
10342             if (!eneed)
10343               break;
10344             endbuf = (char *) eneed + section->sh_size;
10345
10346             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10347               {
10348                 Elf_External_Verneed * entry;
10349                 Elf_Internal_Verneed ent;
10350                 unsigned long isum;
10351                 int j;
10352                 char * vstart;
10353
10354                 vstart = ((char *) eneed) + idx;
10355                 if (vstart + sizeof (*entry) > endbuf)
10356                   break;
10357
10358                 entry = (Elf_External_Verneed *) vstart;
10359
10360                 ent.vn_version = BYTE_GET (entry->vn_version);
10361                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10362                 ent.vn_file    = BYTE_GET (entry->vn_file);
10363                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10364                 ent.vn_next    = BYTE_GET (entry->vn_next);
10365
10366                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10367
10368                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10369                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10370                 else
10371                   printf (_("  File: %lx"), ent.vn_file);
10372
10373                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10374
10375                 /* Check for overflow.  */
10376                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10377                   break;
10378                 vstart += ent.vn_aux;
10379
10380                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10381                   {
10382                     Elf_External_Vernaux * eaux;
10383                     Elf_Internal_Vernaux aux;
10384
10385                     if (vstart + sizeof (*eaux) > endbuf)
10386                       break;
10387                     eaux = (Elf_External_Vernaux *) vstart;
10388
10389                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10390                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10391                     aux.vna_other = BYTE_GET (eaux->vna_other);
10392                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10393                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10394
10395                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10396                       printf (_("  %#06lx:   Name: %s"),
10397                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10398                     else
10399                       printf (_("  %#06lx:   Name index: %lx"),
10400                               isum, aux.vna_name);
10401
10402                     printf (_("  Flags: %s  Version: %d\n"),
10403                             get_ver_flags (aux.vna_flags), aux.vna_other);
10404
10405                     if (aux.vna_next < sizeof (*eaux)
10406                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10407                       {
10408                         warn (_("Invalid vna_next field of %lx\n"),
10409                               aux.vna_next);
10410                         j = ent.vn_cnt;
10411                         break;
10412                       }
10413                     /* Check for overflow.  */
10414                     if (aux.vna_next > (size_t) (endbuf - vstart))
10415                       break;
10416                     isum   += aux.vna_next;
10417                     vstart += aux.vna_next;
10418                   }
10419
10420                 if (j < ent.vn_cnt)
10421                   warn (_("Missing Version Needs auxillary information\n"));
10422
10423                 if (ent.vn_next < sizeof (*entry)
10424                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10425                   {
10426                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10427                     cnt = section->sh_info;
10428                     break;
10429                   }
10430                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10431                   break;
10432                 idx += ent.vn_next;
10433               }
10434
10435             if (cnt < section->sh_info)
10436               warn (_("Missing Version Needs information\n"));
10437
10438             free (eneed);
10439           }
10440           break;
10441
10442         case SHT_GNU_versym:
10443           {
10444             Elf_Internal_Shdr * link_section;
10445             size_t total;
10446             unsigned int cnt;
10447             unsigned char * edata;
10448             unsigned short * data;
10449             char * strtab;
10450             Elf_Internal_Sym * symbols;
10451             Elf_Internal_Shdr * string_sec;
10452             unsigned long num_syms;
10453             long off;
10454
10455             if (section->sh_link >= elf_header.e_shnum)
10456               break;
10457
10458             link_section = section_headers + section->sh_link;
10459             total = section->sh_size / sizeof (Elf_External_Versym);
10460
10461             if (link_section->sh_link >= elf_header.e_shnum)
10462               break;
10463
10464             found = TRUE;
10465
10466             symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10467             if (symbols == NULL)
10468               break;
10469
10470             string_sec = section_headers + link_section->sh_link;
10471
10472             strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10473                                         string_sec->sh_size,
10474                                         _("version string table"));
10475             if (!strtab)
10476               {
10477                 free (symbols);
10478                 break;
10479               }
10480
10481             printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10482                     printable_section_name (section), (unsigned long) total);
10483
10484             printf (_(" Addr: "));
10485             printf_vma (section->sh_addr);
10486             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10487                     (unsigned long) section->sh_offset, section->sh_link,
10488                     printable_section_name (link_section));
10489
10490             off = offset_from_vma (file,
10491                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10492                                    total * sizeof (short));
10493             edata = (unsigned char *) get_data (NULL, file, off, total,
10494                                                 sizeof (short),
10495                                                 _("version symbol data"));
10496             if (!edata)
10497               {
10498                 free (strtab);
10499                 free (symbols);
10500                 break;
10501               }
10502
10503             data = (short unsigned int *) cmalloc (total, sizeof (short));
10504
10505             for (cnt = total; cnt --;)
10506               data[cnt] = byte_get (edata + cnt * sizeof (short),
10507                                     sizeof (short));
10508
10509             free (edata);
10510
10511             for (cnt = 0; cnt < total; cnt += 4)
10512               {
10513                 int j, nn;
10514                 char *name;
10515                 char *invalid = _("*invalid*");
10516
10517                 printf ("  %03x:", cnt);
10518
10519                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10520                   switch (data[cnt + j])
10521                     {
10522                     case 0:
10523                       fputs (_("   0 (*local*)    "), stdout);
10524                       break;
10525
10526                     case 1:
10527                       fputs (_("   1 (*global*)   "), stdout);
10528                       break;
10529
10530                     default:
10531                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10532                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10533
10534                       /* If this index value is greater than the size of the symbols
10535                          array, break to avoid an out-of-bounds read.  */
10536                       if ((unsigned long)(cnt + j) >= num_syms)
10537                         {
10538                           warn (_("invalid index into symbol array\n"));
10539                           break;
10540                         }
10541
10542                       name = NULL;
10543                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10544                         {
10545                           Elf_Internal_Verneed ivn;
10546                           unsigned long offset;
10547
10548                           offset = offset_from_vma
10549                             (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10550                              sizeof (Elf_External_Verneed));
10551
10552                           do
10553                             {
10554                               Elf_Internal_Vernaux ivna;
10555                               Elf_External_Verneed evn;
10556                               Elf_External_Vernaux evna;
10557                               unsigned long a_off;
10558
10559                               if (get_data (&evn, file, offset, sizeof (evn), 1,
10560                                             _("version need")) == NULL)
10561                                 break;
10562
10563                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10564                               ivn.vn_next = BYTE_GET (evn.vn_next);
10565
10566                               a_off = offset + ivn.vn_aux;
10567
10568                               do
10569                                 {
10570                                   if (get_data (&evna, file, a_off, sizeof (evna),
10571                                                 1, _("version need aux (2)")) == NULL)
10572                                     {
10573                                       ivna.vna_next  = 0;
10574                                       ivna.vna_other = 0;
10575                                     }
10576                                   else
10577                                     {
10578                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10579                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10580                                     }
10581
10582                                   a_off += ivna.vna_next;
10583                                 }
10584                               while (ivna.vna_other != data[cnt + j]
10585                                      && ivna.vna_next != 0);
10586
10587                               if (ivna.vna_other == data[cnt + j])
10588                                 {
10589                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10590
10591                                   if (ivna.vna_name >= string_sec->sh_size)
10592                                     name = invalid;
10593                                   else
10594                                     name = strtab + ivna.vna_name;
10595                                   break;
10596                                 }
10597
10598                               offset += ivn.vn_next;
10599                             }
10600                           while (ivn.vn_next);
10601                         }
10602
10603                       if (data[cnt + j] != 0x8001
10604                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10605                         {
10606                           Elf_Internal_Verdef ivd;
10607                           Elf_External_Verdef evd;
10608                           unsigned long offset;
10609
10610                           offset = offset_from_vma
10611                             (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10612                              sizeof evd);
10613
10614                           do
10615                             {
10616                               if (get_data (&evd, file, offset, sizeof (evd), 1,
10617                                             _("version def")) == NULL)
10618                                 {
10619                                   ivd.vd_next = 0;
10620                                   /* PR 17531: file: 046-1082287-0.004.  */
10621                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10622                                   break;
10623                                 }
10624                               else
10625                                 {
10626                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10627                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10628                                 }
10629
10630                               offset += ivd.vd_next;
10631                             }
10632                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10633                                  && ivd.vd_next != 0);
10634
10635                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10636                             {
10637                               Elf_External_Verdaux evda;
10638                               Elf_Internal_Verdaux ivda;
10639
10640                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10641
10642                               if (get_data (&evda, file,
10643                                             offset - ivd.vd_next + ivd.vd_aux,
10644                                             sizeof (evda), 1,
10645                                             _("version def aux")) == NULL)
10646                                 break;
10647
10648                               ivda.vda_name = BYTE_GET (evda.vda_name);
10649
10650                               if (ivda.vda_name >= string_sec->sh_size)
10651                                 name = invalid;
10652                               else if (name != NULL && name != invalid)
10653                                 name = _("*both*");
10654                               else
10655                                 name = strtab + ivda.vda_name;
10656                             }
10657                         }
10658                       if (name != NULL)
10659                         nn += printf ("(%s%-*s",
10660                                       name,
10661                                       12 - (int) strlen (name),
10662                                       ")");
10663
10664                       if (nn < 18)
10665                         printf ("%*c", 18 - nn, ' ');
10666                     }
10667
10668                 putchar ('\n');
10669               }
10670
10671             free (data);
10672             free (strtab);
10673             free (symbols);
10674           }
10675           break;
10676
10677         default:
10678           break;
10679         }
10680     }
10681
10682   if (! found)
10683     printf (_("\nNo version information found in this file.\n"));
10684
10685   return TRUE;
10686 }
10687
10688 static const char *
10689 get_symbol_binding (unsigned int binding)
10690 {
10691   static char buff[32];
10692
10693   switch (binding)
10694     {
10695     case STB_LOCAL:     return "LOCAL";
10696     case STB_GLOBAL:    return "GLOBAL";
10697     case STB_WEAK:      return "WEAK";
10698     default:
10699       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10700         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10701                   binding);
10702       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10703         {
10704           if (binding == STB_GNU_UNIQUE
10705               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10706                   /* GNU is still using the default value 0.  */
10707                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10708             return "UNIQUE";
10709           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10710         }
10711       else
10712         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10713       return buff;
10714     }
10715 }
10716
10717 static const char *
10718 get_symbol_type (unsigned int type)
10719 {
10720   static char buff[32];
10721
10722   switch (type)
10723     {
10724     case STT_NOTYPE:    return "NOTYPE";
10725     case STT_OBJECT:    return "OBJECT";
10726     case STT_FUNC:      return "FUNC";
10727     case STT_SECTION:   return "SECTION";
10728     case STT_FILE:      return "FILE";
10729     case STT_COMMON:    return "COMMON";
10730     case STT_TLS:       return "TLS";
10731     case STT_RELC:      return "RELC";
10732     case STT_SRELC:     return "SRELC";
10733     default:
10734       if (type >= STT_LOPROC && type <= STT_HIPROC)
10735         {
10736           if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10737             return "THUMB_FUNC";
10738
10739           if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10740             return "REGISTER";
10741
10742           if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10743             return "PARISC_MILLI";
10744
10745           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10746         }
10747       else if (type >= STT_LOOS && type <= STT_HIOS)
10748         {
10749           if (elf_header.e_machine == EM_PARISC)
10750             {
10751               if (type == STT_HP_OPAQUE)
10752                 return "HP_OPAQUE";
10753               if (type == STT_HP_STUB)
10754                 return "HP_STUB";
10755             }
10756
10757           if (type == STT_GNU_IFUNC
10758               && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10759                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10760                   /* GNU is still using the default value 0.  */
10761                   || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10762             return "IFUNC";
10763
10764           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10765         }
10766       else
10767         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10768       return buff;
10769     }
10770 }
10771
10772 static const char *
10773 get_symbol_visibility (unsigned int visibility)
10774 {
10775   switch (visibility)
10776     {
10777     case STV_DEFAULT:   return "DEFAULT";
10778     case STV_INTERNAL:  return "INTERNAL";
10779     case STV_HIDDEN:    return "HIDDEN";
10780     case STV_PROTECTED: return "PROTECTED";
10781     default:
10782       error (_("Unrecognized visibility value: %u"), visibility);
10783       return _("<unknown>");
10784     }
10785 }
10786
10787 static const char *
10788 get_solaris_symbol_visibility (unsigned int visibility)
10789 {
10790   switch (visibility)
10791     {
10792     case 4: return "EXPORTED";
10793     case 5: return "SINGLETON";
10794     case 6: return "ELIMINATE";
10795     default: return get_symbol_visibility (visibility);
10796     }
10797 }
10798
10799 static const char *
10800 get_mips_symbol_other (unsigned int other)
10801 {
10802   switch (other)
10803     {
10804     case STO_OPTIONAL:      return "OPTIONAL";
10805     case STO_MIPS_PLT:      return "MIPS PLT";
10806     case STO_MIPS_PIC:      return "MIPS PIC";
10807     case STO_MICROMIPS:     return "MICROMIPS";
10808     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10809     case STO_MIPS16:        return "MIPS16";
10810     default:                return NULL;
10811     }
10812 }
10813
10814 static const char *
10815 get_ia64_symbol_other (unsigned int other)
10816 {
10817   if (is_ia64_vms ())
10818     {
10819       static char res[32];
10820
10821       res[0] = 0;
10822
10823       /* Function types is for images and .STB files only.  */
10824       switch (elf_header.e_type)
10825         {
10826         case ET_DYN:
10827         case ET_EXEC:
10828           switch (VMS_ST_FUNC_TYPE (other))
10829             {
10830             case VMS_SFT_CODE_ADDR:
10831               strcat (res, " CA");
10832               break;
10833             case VMS_SFT_SYMV_IDX:
10834               strcat (res, " VEC");
10835               break;
10836             case VMS_SFT_FD:
10837               strcat (res, " FD");
10838               break;
10839             case VMS_SFT_RESERVE:
10840               strcat (res, " RSV");
10841               break;
10842             default:
10843               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10844                     VMS_ST_FUNC_TYPE (other));
10845               strcat (res, " <unknown>");
10846               break;
10847             }
10848           break;
10849         default:
10850           break;
10851         }
10852       switch (VMS_ST_LINKAGE (other))
10853         {
10854         case VMS_STL_IGNORE:
10855           strcat (res, " IGN");
10856           break;
10857         case VMS_STL_RESERVE:
10858           strcat (res, " RSV");
10859           break;
10860         case VMS_STL_STD:
10861           strcat (res, " STD");
10862           break;
10863         case VMS_STL_LNK:
10864           strcat (res, " LNK");
10865           break;
10866         default:
10867           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10868                 VMS_ST_LINKAGE (other));
10869           strcat (res, " <unknown>");
10870           break;
10871         }
10872
10873       if (res[0] != 0)
10874         return res + 1;
10875       else
10876         return res;
10877     }
10878   return NULL;
10879 }
10880
10881 static const char *
10882 get_ppc64_symbol_other (unsigned int other)
10883 {
10884   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10885     {
10886       static char buf[32];
10887       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10888                 PPC64_LOCAL_ENTRY_OFFSET (other));
10889       return buf;
10890     }
10891   return NULL;
10892 }
10893
10894 static const char *
10895 get_symbol_other (unsigned int other)
10896 {
10897   const char * result = NULL;
10898   static char buff [32];
10899
10900   if (other == 0)
10901     return "";
10902
10903   switch (elf_header.e_machine)
10904     {
10905     case EM_MIPS:
10906       result = get_mips_symbol_other (other);
10907       break;
10908     case EM_IA_64:
10909       result = get_ia64_symbol_other (other);
10910       break;
10911     case EM_PPC64:
10912       result = get_ppc64_symbol_other (other);
10913       break;
10914     default:
10915       result = NULL;
10916       break;
10917     }
10918
10919   if (result)
10920     return result;
10921
10922   snprintf (buff, sizeof buff, _("<other>: %x"), other);
10923   return buff;
10924 }
10925
10926 static const char *
10927 get_symbol_index_type (unsigned int type)
10928 {
10929   static char buff[32];
10930
10931   switch (type)
10932     {
10933     case SHN_UNDEF:     return "UND";
10934     case SHN_ABS:       return "ABS";
10935     case SHN_COMMON:    return "COM";
10936     default:
10937       if (type == SHN_IA_64_ANSI_COMMON
10938           && elf_header.e_machine == EM_IA_64
10939           && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10940         return "ANSI_COM";
10941       else if ((elf_header.e_machine == EM_X86_64
10942                 || elf_header.e_machine == EM_L1OM
10943                 || elf_header.e_machine == EM_K1OM)
10944                && type == SHN_X86_64_LCOMMON)
10945         return "LARGE_COM";
10946       else if ((type == SHN_MIPS_SCOMMON
10947                 && elf_header.e_machine == EM_MIPS)
10948                || (type == SHN_TIC6X_SCOMMON
10949                    && elf_header.e_machine == EM_TI_C6000))
10950         return "SCOM";
10951       else if (type == SHN_MIPS_SUNDEFINED
10952                && elf_header.e_machine == EM_MIPS)
10953         return "SUND";
10954       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10955         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10956       else if (type >= SHN_LOOS && type <= SHN_HIOS)
10957         sprintf (buff, "OS [0x%04x]", type & 0xffff);
10958       else if (type >= SHN_LORESERVE)
10959         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10960       else if (type >= elf_header.e_shnum)
10961         sprintf (buff, _("bad section index[%3d]"), type);
10962       else
10963         sprintf (buff, "%3d", type);
10964       break;
10965     }
10966
10967   return buff;
10968 }
10969
10970 static bfd_vma *
10971 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10972 {
10973   unsigned char * e_data;
10974   bfd_vma * i_data;
10975
10976   /* If the size_t type is smaller than the bfd_size_type, eg because
10977      you are building a 32-bit tool on a 64-bit host, then make sure
10978      that when (number) is cast to (size_t) no information is lost.  */
10979   if (sizeof (size_t) < sizeof (bfd_size_type)
10980       && (bfd_size_type) ((size_t) number) != number)
10981     {
10982       error (_("Size truncation prevents reading %s elements of size %u\n"),
10983              bfd_vmatoa ("u", number), ent_size);
10984       return NULL;
10985     }
10986
10987   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10988      attempting to allocate memory when the read is bound to fail.  */
10989   if (ent_size * number > current_file_size)
10990     {
10991       error (_("Invalid number of dynamic entries: %s\n"),
10992              bfd_vmatoa ("u", number));
10993       return NULL;
10994     }
10995
10996   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10997   if (e_data == NULL)
10998     {
10999       error (_("Out of memory reading %s dynamic entries\n"),
11000              bfd_vmatoa ("u", number));
11001       return NULL;
11002     }
11003
11004   if (fread (e_data, ent_size, (size_t) number, file) != number)
11005     {
11006       error (_("Unable to read in %s bytes of dynamic data\n"),
11007              bfd_vmatoa ("u", number * ent_size));
11008       free (e_data);
11009       return NULL;
11010     }
11011
11012   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11013   if (i_data == NULL)
11014     {
11015       error (_("Out of memory allocating space for %s dynamic entries\n"),
11016              bfd_vmatoa ("u", number));
11017       free (e_data);
11018       return NULL;
11019     }
11020
11021   while (number--)
11022     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11023
11024   free (e_data);
11025
11026   return i_data;
11027 }
11028
11029 static void
11030 print_dynamic_symbol (bfd_vma si, unsigned long hn)
11031 {
11032   Elf_Internal_Sym * psym;
11033   int n;
11034
11035   n = print_vma (si, DEC_5);
11036   if (n < 5)
11037     fputs (&"     "[n], stdout);
11038   printf (" %3lu: ", hn);
11039
11040   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11041     {
11042       printf (_("<No info available for dynamic symbol number %lu>\n"),
11043               (unsigned long) si);
11044       return;
11045     }
11046
11047   psym = dynamic_symbols + si;
11048   print_vma (psym->st_value, LONG_HEX);
11049   putchar (' ');
11050   print_vma (psym->st_size, DEC_5);
11051
11052   printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11053   printf (" %-6s",  get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11054
11055   if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11056     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11057   else
11058     {
11059       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11060
11061       printf (" %-7s",  get_symbol_visibility (vis));
11062       /* Check to see if any other bits in the st_other field are set.
11063          Note - displaying this information disrupts the layout of the
11064          table being generated, but for the moment this case is very
11065          rare.  */
11066       if (psym->st_other ^ vis)
11067         printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11068     }
11069
11070   printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11071   if (VALID_DYNAMIC_NAME (psym->st_name))
11072     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11073   else
11074     printf (_(" <corrupt: %14ld>"), psym->st_name);
11075   putchar ('\n');
11076 }
11077
11078 static const char *
11079 get_symbol_version_string (FILE *                       file,
11080                            bfd_boolean                  is_dynsym,
11081                            const char *                 strtab,
11082                            unsigned long int            strtab_size,
11083                            unsigned int                 si,
11084                            Elf_Internal_Sym *           psym,
11085                            enum versioned_symbol_info * sym_info,
11086                            unsigned short *             vna_other)
11087 {
11088   unsigned char data[2];
11089   unsigned short vers_data;
11090   unsigned long offset;
11091
11092   if (!is_dynsym
11093       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11094     return NULL;
11095
11096   offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11097                             sizeof data + si * sizeof (vers_data));
11098
11099   if (get_data (&data, file, offset + si * sizeof (vers_data),
11100                 sizeof (data), 1, _("version data")) == NULL)
11101     return NULL;
11102
11103   vers_data = byte_get (data, 2);
11104
11105   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11106     return NULL;
11107
11108   /* Usually we'd only see verdef for defined symbols, and verneed for
11109      undefined symbols.  However, symbols defined by the linker in
11110      .dynbss for variables copied from a shared library in order to
11111      avoid text relocations are defined yet have verneed.  We could
11112      use a heuristic to detect the special case, for example, check
11113      for verneed first on symbols defined in SHT_NOBITS sections, but
11114      it is simpler and more reliable to just look for both verdef and
11115      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11116
11117   if (psym->st_shndx != SHN_UNDEF
11118       && vers_data != 0x8001
11119       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11120     {
11121       Elf_Internal_Verdef ivd;
11122       Elf_Internal_Verdaux ivda;
11123       Elf_External_Verdaux evda;
11124       unsigned long off;
11125
11126       off = offset_from_vma (file,
11127                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11128                              sizeof (Elf_External_Verdef));
11129
11130       do
11131         {
11132           Elf_External_Verdef evd;
11133
11134           if (get_data (&evd, file, off, sizeof (evd), 1,
11135                         _("version def")) == NULL)
11136             {
11137               ivd.vd_ndx = 0;
11138               ivd.vd_aux = 0;
11139               ivd.vd_next = 0;
11140             }
11141           else
11142             {
11143               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11144               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11145               ivd.vd_next = BYTE_GET (evd.vd_next);
11146             }
11147
11148           off += ivd.vd_next;
11149         }
11150       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11151
11152       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11153         {
11154           off -= ivd.vd_next;
11155           off += ivd.vd_aux;
11156
11157           if (get_data (&evda, file, off, sizeof (evda), 1,
11158                         _("version def aux")) != NULL)
11159             {
11160               ivda.vda_name = BYTE_GET (evda.vda_name);
11161
11162               if (psym->st_name != ivda.vda_name)
11163                 {
11164                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11165                                ? symbol_hidden : symbol_public);
11166                   return (ivda.vda_name < strtab_size
11167                           ? strtab + ivda.vda_name : _("<corrupt>"));
11168                 }
11169             }
11170         }
11171     }
11172
11173   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11174     {
11175       Elf_External_Verneed evn;
11176       Elf_Internal_Verneed ivn;
11177       Elf_Internal_Vernaux ivna;
11178
11179       offset = offset_from_vma (file,
11180                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11181                                 sizeof evn);
11182       do
11183         {
11184           unsigned long vna_off;
11185
11186           if (get_data (&evn, file, offset, sizeof (evn), 1,
11187                         _("version need")) == NULL)
11188             {
11189               ivna.vna_next = 0;
11190               ivna.vna_other = 0;
11191               ivna.vna_name = 0;
11192               break;
11193             }
11194
11195           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11196           ivn.vn_next = BYTE_GET (evn.vn_next);
11197
11198           vna_off = offset + ivn.vn_aux;
11199
11200           do
11201             {
11202               Elf_External_Vernaux evna;
11203
11204               if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11205                             _("version need aux (3)")) == NULL)
11206                 {
11207                   ivna.vna_next = 0;
11208                   ivna.vna_other = 0;
11209                   ivna.vna_name = 0;
11210                 }
11211               else
11212                 {
11213                   ivna.vna_other = BYTE_GET (evna.vna_other);
11214                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11215                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11216                 }
11217
11218               vna_off += ivna.vna_next;
11219             }
11220           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11221
11222           if (ivna.vna_other == vers_data)
11223             break;
11224
11225           offset += ivn.vn_next;
11226         }
11227       while (ivn.vn_next != 0);
11228
11229       if (ivna.vna_other == vers_data)
11230         {
11231           *sym_info = symbol_undefined;
11232           *vna_other = ivna.vna_other;
11233           return (ivna.vna_name < strtab_size
11234                   ? strtab + ivna.vna_name : _("<corrupt>"));
11235         }
11236     }
11237   return NULL;
11238 }
11239
11240 /* Dump the symbol table.  */
11241 static bfd_boolean
11242 process_symbol_table (FILE * file)
11243 {
11244   Elf_Internal_Shdr * section;
11245   bfd_size_type nbuckets = 0;
11246   bfd_size_type nchains = 0;
11247   bfd_vma * buckets = NULL;
11248   bfd_vma * chains = NULL;
11249   bfd_vma ngnubuckets = 0;
11250   bfd_vma * gnubuckets = NULL;
11251   bfd_vma * gnuchains = NULL;
11252   bfd_vma gnusymidx = 0;
11253   bfd_size_type ngnuchains = 0;
11254
11255   if (!do_syms && !do_dyn_syms && !do_histogram)
11256     return TRUE;
11257
11258   if (dynamic_info[DT_HASH]
11259       && (do_histogram
11260           || (do_using_dynamic
11261               && !do_dyn_syms
11262               && dynamic_strings != NULL)))
11263     {
11264       unsigned char nb[8];
11265       unsigned char nc[8];
11266       unsigned int hash_ent_size = 4;
11267
11268       if ((elf_header.e_machine == EM_ALPHA
11269            || elf_header.e_machine == EM_S390
11270            || elf_header.e_machine == EM_S390_OLD)
11271           && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11272         hash_ent_size = 8;
11273
11274       if (fseek (file,
11275                  (archive_file_offset
11276                   + offset_from_vma (file, dynamic_info[DT_HASH],
11277                                      sizeof nb + sizeof nc)),
11278                  SEEK_SET))
11279         {
11280           error (_("Unable to seek to start of dynamic information\n"));
11281           goto no_hash;
11282         }
11283
11284       if (fread (nb, hash_ent_size, 1, file) != 1)
11285         {
11286           error (_("Failed to read in number of buckets\n"));
11287           goto no_hash;
11288         }
11289
11290       if (fread (nc, hash_ent_size, 1, file) != 1)
11291         {
11292           error (_("Failed to read in number of chains\n"));
11293           goto no_hash;
11294         }
11295
11296       nbuckets = byte_get (nb, hash_ent_size);
11297       nchains  = byte_get (nc, hash_ent_size);
11298
11299       buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11300       chains  = get_dynamic_data (file, nchains, hash_ent_size);
11301
11302     no_hash:
11303       if (buckets == NULL || chains == NULL)
11304         {
11305           if (do_using_dynamic)
11306             return FALSE;
11307           free (buckets);
11308           free (chains);
11309           buckets = NULL;
11310           chains = NULL;
11311           nbuckets = 0;
11312           nchains = 0;
11313         }
11314     }
11315
11316   if (dynamic_info_DT_GNU_HASH
11317       && (do_histogram
11318           || (do_using_dynamic
11319               && !do_dyn_syms
11320               && dynamic_strings != NULL)))
11321     {
11322       unsigned char nb[16];
11323       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11324       bfd_vma buckets_vma;
11325
11326       if (fseek (file,
11327                  (archive_file_offset
11328                   + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11329                                      sizeof nb)),
11330                  SEEK_SET))
11331         {
11332           error (_("Unable to seek to start of dynamic information\n"));
11333           goto no_gnu_hash;
11334         }
11335
11336       if (fread (nb, 16, 1, file) != 1)
11337         {
11338           error (_("Failed to read in number of buckets\n"));
11339           goto no_gnu_hash;
11340         }
11341
11342       ngnubuckets = byte_get (nb, 4);
11343       gnusymidx = byte_get (nb + 4, 4);
11344       bitmaskwords = byte_get (nb + 8, 4);
11345       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11346       if (is_32bit_elf)
11347         buckets_vma += bitmaskwords * 4;
11348       else
11349         buckets_vma += bitmaskwords * 8;
11350
11351       if (fseek (file,
11352                  (archive_file_offset
11353                   + offset_from_vma (file, buckets_vma, 4)),
11354                  SEEK_SET))
11355         {
11356           error (_("Unable to seek to start of dynamic information\n"));
11357           goto no_gnu_hash;
11358         }
11359
11360       gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11361
11362       if (gnubuckets == NULL)
11363         goto no_gnu_hash;
11364
11365       for (i = 0; i < ngnubuckets; i++)
11366         if (gnubuckets[i] != 0)
11367           {
11368             if (gnubuckets[i] < gnusymidx)
11369               return FALSE;
11370
11371             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11372               maxchain = gnubuckets[i];
11373           }
11374
11375       if (maxchain == 0xffffffff)
11376         goto no_gnu_hash;
11377
11378       maxchain -= gnusymidx;
11379
11380       if (fseek (file,
11381                  (archive_file_offset
11382                   + offset_from_vma (file, buckets_vma
11383                                            + 4 * (ngnubuckets + maxchain), 4)),
11384                  SEEK_SET))
11385         {
11386           error (_("Unable to seek to start of dynamic information\n"));
11387           goto no_gnu_hash;
11388         }
11389
11390       do
11391         {
11392           if (fread (nb, 4, 1, file) != 1)
11393             {
11394               error (_("Failed to determine last chain length\n"));
11395               goto no_gnu_hash;
11396             }
11397
11398           if (maxchain + 1 == 0)
11399             goto no_gnu_hash;
11400
11401           ++maxchain;
11402         }
11403       while ((byte_get (nb, 4) & 1) == 0);
11404
11405       if (fseek (file,
11406                  (archive_file_offset
11407                   + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11408                  SEEK_SET))
11409         {
11410           error (_("Unable to seek to start of dynamic information\n"));
11411           goto no_gnu_hash;
11412         }
11413
11414       gnuchains = get_dynamic_data (file, maxchain, 4);
11415       ngnuchains = maxchain;
11416
11417     no_gnu_hash:
11418       if (gnuchains == NULL)
11419         {
11420           free (gnubuckets);
11421           gnubuckets = NULL;
11422           ngnubuckets = 0;
11423           if (do_using_dynamic)
11424             return FALSE;
11425         }
11426     }
11427
11428   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11429       && do_syms
11430       && do_using_dynamic
11431       && dynamic_strings != NULL
11432       && dynamic_symbols != NULL)
11433     {
11434       unsigned long hn;
11435
11436       if (dynamic_info[DT_HASH])
11437         {
11438           bfd_vma si;
11439
11440           printf (_("\nSymbol table for image:\n"));
11441           if (is_32bit_elf)
11442             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11443           else
11444             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11445
11446           for (hn = 0; hn < nbuckets; hn++)
11447             {
11448               if (! buckets[hn])
11449                 continue;
11450
11451               for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11452                 print_dynamic_symbol (si, hn);
11453             }
11454         }
11455
11456       if (dynamic_info_DT_GNU_HASH)
11457         {
11458           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11459           if (is_32bit_elf)
11460             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11461           else
11462             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11463
11464           for (hn = 0; hn < ngnubuckets; ++hn)
11465             if (gnubuckets[hn] != 0)
11466               {
11467                 bfd_vma si = gnubuckets[hn];
11468                 bfd_vma off = si - gnusymidx;
11469
11470                 do
11471                   {
11472                     print_dynamic_symbol (si, hn);
11473                     si++;
11474                   }
11475                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11476               }
11477         }
11478     }
11479   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11480            && section_headers != NULL)
11481     {
11482       unsigned int i;
11483
11484       for (i = 0, section = section_headers;
11485            i < elf_header.e_shnum;
11486            i++, section++)
11487         {
11488           unsigned int si;
11489           char * strtab = NULL;
11490           unsigned long int strtab_size = 0;
11491           Elf_Internal_Sym * symtab;
11492           Elf_Internal_Sym * psym;
11493           unsigned long num_syms;
11494
11495           if ((section->sh_type != SHT_SYMTAB
11496                && section->sh_type != SHT_DYNSYM)
11497               || (!do_syms
11498                   && section->sh_type == SHT_SYMTAB))
11499             continue;
11500
11501           if (section->sh_entsize == 0)
11502             {
11503               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11504                       printable_section_name (section));
11505               continue;
11506             }
11507
11508           printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11509                   printable_section_name (section),
11510                   (unsigned long) (section->sh_size / section->sh_entsize));
11511
11512           if (is_32bit_elf)
11513             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11514           else
11515             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11516
11517           symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11518           if (symtab == NULL)
11519             continue;
11520
11521           if (section->sh_link == elf_header.e_shstrndx)
11522             {
11523               strtab = string_table;
11524               strtab_size = string_table_length;
11525             }
11526           else if (section->sh_link < elf_header.e_shnum)
11527             {
11528               Elf_Internal_Shdr * string_sec;
11529
11530               string_sec = section_headers + section->sh_link;
11531
11532               strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11533                                           1, string_sec->sh_size,
11534                                           _("string table"));
11535               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11536             }
11537
11538           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11539             {
11540               const char *version_string;
11541               enum versioned_symbol_info sym_info;
11542               unsigned short vna_other;
11543
11544               printf ("%6d: ", si);
11545               print_vma (psym->st_value, LONG_HEX);
11546               putchar (' ');
11547               print_vma (psym->st_size, DEC_5);
11548               printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11549               printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11550               if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11551                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11552               else
11553                 {
11554                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11555
11556                   printf (" %-7s", get_symbol_visibility (vis));
11557                   /* Check to see if any other bits in the st_other field are set.
11558                      Note - displaying this information disrupts the layout of the
11559                      table being generated, but for the moment this case is very rare.  */
11560                   if (psym->st_other ^ vis)
11561                     printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11562                 }
11563               printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11564               print_symbol (25, psym->st_name < strtab_size
11565                             ? strtab + psym->st_name : _("<corrupt>"));
11566
11567               version_string
11568                 = get_symbol_version_string (file,
11569                                              section->sh_type == SHT_DYNSYM,
11570                                              strtab, strtab_size, si,
11571                                              psym, &sym_info, &vna_other);
11572               if (version_string)
11573                 {
11574                   if (sym_info == symbol_undefined)
11575                     printf ("@%s (%d)", version_string, vna_other);
11576                   else
11577                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11578                             version_string);
11579                 }
11580
11581               putchar ('\n');
11582
11583               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11584                   && si >= section->sh_info
11585                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11586                   && elf_header.e_machine != EM_MIPS
11587                   /* Solaris binaries have been found to violate this requirement as
11588                      well.  Not sure if this is a bug or an ABI requirement.  */
11589                   && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11590                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11591                       si, printable_section_name (section), section->sh_info);
11592             }
11593
11594           free (symtab);
11595           if (strtab != string_table)
11596             free (strtab);
11597         }
11598     }
11599   else if (do_syms)
11600     printf
11601       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11602
11603   if (do_histogram && buckets != NULL)
11604     {
11605       unsigned long * lengths;
11606       unsigned long * counts;
11607       unsigned long hn;
11608       bfd_vma si;
11609       unsigned long maxlength = 0;
11610       unsigned long nzero_counts = 0;
11611       unsigned long nsyms = 0;
11612       unsigned long chained;
11613
11614       printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11615               (unsigned long) nbuckets);
11616
11617       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11618       if (lengths == NULL)
11619         {
11620           error (_("Out of memory allocating space for histogram buckets\n"));
11621           return FALSE;
11622         }
11623
11624       printf (_(" Length  Number     %% of total  Coverage\n"));
11625       for (hn = 0; hn < nbuckets; ++hn)
11626         {
11627           for (si = buckets[hn], chained = 0;
11628                si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11629                si = chains[si], ++chained)
11630             {
11631               ++nsyms;
11632               if (maxlength < ++lengths[hn])
11633                 ++maxlength;
11634             }
11635
11636             /* PR binutils/17531: A corrupt binary could contain broken
11637                histogram data.  Do not go into an infinite loop trying
11638                to process it.  */
11639             if (chained > nchains)
11640               {
11641                 error (_("histogram chain is corrupt\n"));
11642                 break;
11643               }
11644         }
11645
11646       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11647       if (counts == NULL)
11648         {
11649           free (lengths);
11650           error (_("Out of memory allocating space for histogram counts\n"));
11651           return FALSE;
11652         }
11653
11654       for (hn = 0; hn < nbuckets; ++hn)
11655         ++counts[lengths[hn]];
11656
11657       if (nbuckets > 0)
11658         {
11659           unsigned long i;
11660           printf ("      0  %-10lu (%5.1f%%)\n",
11661                   counts[0], (counts[0] * 100.0) / nbuckets);
11662           for (i = 1; i <= maxlength; ++i)
11663             {
11664               nzero_counts += counts[i] * i;
11665               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11666                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11667                       (nzero_counts * 100.0) / nsyms);
11668             }
11669         }
11670
11671       free (counts);
11672       free (lengths);
11673     }
11674
11675   if (buckets != NULL)
11676     {
11677       free (buckets);
11678       free (chains);
11679     }
11680
11681   if (do_histogram && gnubuckets != NULL)
11682     {
11683       unsigned long * lengths;
11684       unsigned long * counts;
11685       unsigned long hn;
11686       unsigned long maxlength = 0;
11687       unsigned long nzero_counts = 0;
11688       unsigned long nsyms = 0;
11689
11690       printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11691               (unsigned long) ngnubuckets);
11692
11693       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11694       if (lengths == NULL)
11695         {
11696           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11697           return FALSE;
11698         }
11699
11700       printf (_(" Length  Number     %% of total  Coverage\n"));
11701
11702       for (hn = 0; hn < ngnubuckets; ++hn)
11703         if (gnubuckets[hn] != 0)
11704           {
11705             bfd_vma off, length = 1;
11706
11707             for (off = gnubuckets[hn] - gnusymidx;
11708                  /* PR 17531 file: 010-77222-0.004.  */
11709                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11710                  ++off)
11711               ++length;
11712             lengths[hn] = length;
11713             if (length > maxlength)
11714               maxlength = length;
11715             nsyms += length;
11716           }
11717
11718       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11719       if (counts == NULL)
11720         {
11721           free (lengths);
11722           error (_("Out of memory allocating space for gnu histogram counts\n"));
11723           return FALSE;
11724         }
11725
11726       for (hn = 0; hn < ngnubuckets; ++hn)
11727         ++counts[lengths[hn]];
11728
11729       if (ngnubuckets > 0)
11730         {
11731           unsigned long j;
11732           printf ("      0  %-10lu (%5.1f%%)\n",
11733                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11734           for (j = 1; j <= maxlength; ++j)
11735             {
11736               nzero_counts += counts[j] * j;
11737               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11738                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11739                       (nzero_counts * 100.0) / nsyms);
11740             }
11741         }
11742
11743       free (counts);
11744       free (lengths);
11745       free (gnubuckets);
11746       free (gnuchains);
11747     }
11748
11749   return TRUE;
11750 }
11751
11752 static bfd_boolean
11753 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11754 {
11755   unsigned int i;
11756
11757   if (dynamic_syminfo == NULL
11758       || !do_dynamic)
11759     /* No syminfo, this is ok.  */
11760     return TRUE;
11761
11762   /* There better should be a dynamic symbol section.  */
11763   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11764     return FALSE;
11765
11766   if (dynamic_addr)
11767     printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11768             dynamic_syminfo_offset, dynamic_syminfo_nent);
11769
11770   printf (_(" Num: Name                           BoundTo     Flags\n"));
11771   for (i = 0; i < dynamic_syminfo_nent; ++i)
11772     {
11773       unsigned short int flags = dynamic_syminfo[i].si_flags;
11774
11775       printf ("%4d: ", i);
11776       if (i >= num_dynamic_syms)
11777         printf (_("<corrupt index>"));
11778       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11779         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11780       else
11781         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11782       putchar (' ');
11783
11784       switch (dynamic_syminfo[i].si_boundto)
11785         {
11786         case SYMINFO_BT_SELF:
11787           fputs ("SELF       ", stdout);
11788           break;
11789         case SYMINFO_BT_PARENT:
11790           fputs ("PARENT     ", stdout);
11791           break;
11792         default:
11793           if (dynamic_syminfo[i].si_boundto > 0
11794               && dynamic_syminfo[i].si_boundto < dynamic_nent
11795               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11796             {
11797               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11798               putchar (' ' );
11799             }
11800           else
11801             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11802           break;
11803         }
11804
11805       if (flags & SYMINFO_FLG_DIRECT)
11806         printf (" DIRECT");
11807       if (flags & SYMINFO_FLG_PASSTHRU)
11808         printf (" PASSTHRU");
11809       if (flags & SYMINFO_FLG_COPY)
11810         printf (" COPY");
11811       if (flags & SYMINFO_FLG_LAZYLOAD)
11812         printf (" LAZYLOAD");
11813
11814       puts ("");
11815     }
11816
11817   return TRUE;
11818 }
11819
11820 #define IN_RANGE(START,END,ADDR,OFF)            \
11821   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11822
11823 /* Check to see if the given reloc needs to be handled in a target specific
11824    manner.  If so then process the reloc and return TRUE otherwise return
11825    FALSE.
11826
11827    If called with reloc == NULL, then this is a signal that reloc processing
11828    for the current section has finished, and any saved state should be
11829    discarded.  */
11830
11831 static bfd_boolean
11832 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11833                                 unsigned char *     start,
11834                                 unsigned char *     end,
11835                                 Elf_Internal_Sym *  symtab,
11836                                 unsigned long       num_syms)
11837 {
11838   unsigned int reloc_type = 0;
11839   unsigned long sym_index = 0;
11840
11841   if (reloc)
11842     {
11843       reloc_type = get_reloc_type (reloc->r_info);
11844       sym_index = get_reloc_symindex (reloc->r_info);
11845     }
11846
11847   switch (elf_header.e_machine)
11848     {
11849     case EM_MSP430:
11850     case EM_MSP430_OLD:
11851       {
11852         static Elf_Internal_Sym * saved_sym = NULL;
11853
11854         if (reloc == NULL)
11855           {
11856             saved_sym = NULL;
11857             return TRUE;
11858           }
11859
11860         switch (reloc_type)
11861           {
11862           case 10: /* R_MSP430_SYM_DIFF */
11863             if (uses_msp430x_relocs ())
11864               break;
11865             /* Fall through.  */
11866           case 21: /* R_MSP430X_SYM_DIFF */
11867             /* PR 21139.  */
11868             if (sym_index >= num_syms)
11869               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11870                      sym_index);
11871             else
11872               saved_sym = symtab + sym_index;
11873             return TRUE;
11874
11875           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11876           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11877             goto handle_sym_diff;
11878
11879           case 5: /* R_MSP430_16_BYTE */
11880           case 9: /* R_MSP430_8 */
11881             if (uses_msp430x_relocs ())
11882               break;
11883             goto handle_sym_diff;
11884
11885           case 2: /* R_MSP430_ABS16 */
11886           case 15: /* R_MSP430X_ABS16 */
11887             if (! uses_msp430x_relocs ())
11888               break;
11889             goto handle_sym_diff;
11890
11891           handle_sym_diff:
11892             if (saved_sym != NULL)
11893               {
11894                 int reloc_size = reloc_type == 1 ? 4 : 2;
11895                 bfd_vma value;
11896
11897                 if (sym_index >= num_syms)
11898                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11899                          sym_index);
11900                 else
11901                   {
11902                     value = reloc->r_addend + (symtab[sym_index].st_value
11903                                                - saved_sym->st_value);
11904
11905                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11906                       byte_put (start + reloc->r_offset, value, reloc_size);
11907                     else
11908                       /* PR 21137 */
11909                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11910                              (long) reloc->r_offset);
11911                   }
11912
11913                 saved_sym = NULL;
11914                 return TRUE;
11915               }
11916             break;
11917
11918           default:
11919             if (saved_sym != NULL)
11920               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11921             break;
11922           }
11923         break;
11924       }
11925
11926     case EM_MN10300:
11927     case EM_CYGNUS_MN10300:
11928       {
11929         static Elf_Internal_Sym * saved_sym = NULL;
11930
11931         if (reloc == NULL)
11932           {
11933             saved_sym = NULL;
11934             return TRUE;
11935           }
11936
11937         switch (reloc_type)
11938           {
11939           case 34: /* R_MN10300_ALIGN */
11940             return TRUE;
11941           case 33: /* R_MN10300_SYM_DIFF */
11942             if (sym_index >= num_syms)
11943               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11944                      sym_index);
11945             else
11946               saved_sym = symtab + sym_index;
11947             return TRUE;
11948
11949           case 1: /* R_MN10300_32 */
11950           case 2: /* R_MN10300_16 */
11951             if (saved_sym != NULL)
11952               {
11953                 int reloc_size = reloc_type == 1 ? 4 : 2;
11954                 bfd_vma value;
11955
11956                 if (sym_index >= num_syms)
11957                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11958                          sym_index);
11959                 else
11960                   {
11961                     value = reloc->r_addend + (symtab[sym_index].st_value
11962                                                - saved_sym->st_value);
11963
11964                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11965                       byte_put (start + reloc->r_offset, value, reloc_size);
11966                     else
11967                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11968                              (long) reloc->r_offset);
11969                   }
11970
11971                 saved_sym = NULL;
11972                 return TRUE;
11973               }
11974             break;
11975           default:
11976             if (saved_sym != NULL)
11977               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11978             break;
11979           }
11980         break;
11981       }
11982
11983     case EM_RL78:
11984       {
11985         static bfd_vma saved_sym1 = 0;
11986         static bfd_vma saved_sym2 = 0;
11987         static bfd_vma value;
11988
11989         if (reloc == NULL)
11990           {
11991             saved_sym1 = saved_sym2 = 0;
11992             return TRUE;
11993           }
11994
11995         switch (reloc_type)
11996           {
11997           case 0x80: /* R_RL78_SYM.  */
11998             saved_sym1 = saved_sym2;
11999             if (sym_index >= num_syms)
12000               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12001                      sym_index);
12002             else
12003               {
12004                 saved_sym2 = symtab[sym_index].st_value;
12005                 saved_sym2 += reloc->r_addend;
12006               }
12007             return TRUE;
12008
12009           case 0x83: /* R_RL78_OPsub.  */
12010             value = saved_sym1 - saved_sym2;
12011             saved_sym2 = saved_sym1 = 0;
12012             return TRUE;
12013             break;
12014
12015           case 0x41: /* R_RL78_ABS32.  */
12016             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12017               byte_put (start + reloc->r_offset, value, 4);
12018             else
12019               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12020                      (long) reloc->r_offset);
12021             value = 0;
12022             return TRUE;
12023
12024           case 0x43: /* R_RL78_ABS16.  */
12025             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12026               byte_put (start + reloc->r_offset, value, 2);
12027             else
12028               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12029                      (long) reloc->r_offset);
12030             value = 0;
12031             return TRUE;
12032
12033           default:
12034             break;
12035           }
12036         break;
12037       }
12038     }
12039
12040   return FALSE;
12041 }
12042
12043 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12044    DWARF debug sections.  This is a target specific test.  Note - we do not
12045    go through the whole including-target-headers-multiple-times route, (as
12046    we have already done with <elf/h8.h>) because this would become very
12047    messy and even then this function would have to contain target specific
12048    information (the names of the relocs instead of their numeric values).
12049    FIXME: This is not the correct way to solve this problem.  The proper way
12050    is to have target specific reloc sizing and typing functions created by
12051    the reloc-macros.h header, in the same way that it already creates the
12052    reloc naming functions.  */
12053
12054 static bfd_boolean
12055 is_32bit_abs_reloc (unsigned int reloc_type)
12056 {
12057   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12058   switch (elf_header.e_machine)
12059     {
12060     case EM_386:
12061     case EM_IAMCU:
12062       return reloc_type == 1; /* R_386_32.  */
12063     case EM_68K:
12064       return reloc_type == 1; /* R_68K_32.  */
12065     case EM_860:
12066       return reloc_type == 1; /* R_860_32.  */
12067     case EM_960:
12068       return reloc_type == 2; /* R_960_32.  */
12069     case EM_AARCH64:
12070       return (reloc_type == 258
12071               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12072     case EM_ADAPTEVA_EPIPHANY:
12073       return reloc_type == 3;
12074     case EM_ALPHA:
12075       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12076     case EM_ARC:
12077       return reloc_type == 1; /* R_ARC_32.  */
12078     case EM_ARC_COMPACT:
12079     case EM_ARC_COMPACT2:
12080       return reloc_type == 4; /* R_ARC_32.  */
12081     case EM_ARM:
12082       return reloc_type == 2; /* R_ARM_ABS32 */
12083     case EM_AVR_OLD:
12084     case EM_AVR:
12085       return reloc_type == 1;
12086     case EM_BLACKFIN:
12087       return reloc_type == 0x12; /* R_byte4_data.  */
12088     case EM_CRIS:
12089       return reloc_type == 3; /* R_CRIS_32.  */
12090     case EM_CR16:
12091       return reloc_type == 3; /* R_CR16_NUM32.  */
12092     case EM_CRX:
12093       return reloc_type == 15; /* R_CRX_NUM32.  */
12094     case EM_CYGNUS_FRV:
12095       return reloc_type == 1;
12096     case EM_CYGNUS_D10V:
12097     case EM_D10V:
12098       return reloc_type == 6; /* R_D10V_32.  */
12099     case EM_CYGNUS_D30V:
12100     case EM_D30V:
12101       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12102     case EM_DLX:
12103       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12104     case EM_CYGNUS_FR30:
12105     case EM_FR30:
12106       return reloc_type == 3; /* R_FR30_32.  */
12107     case EM_FT32:
12108       return reloc_type == 1; /* R_FT32_32.  */
12109     case EM_H8S:
12110     case EM_H8_300:
12111     case EM_H8_300H:
12112       return reloc_type == 1; /* R_H8_DIR32.  */
12113     case EM_IA_64:
12114       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12115               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12116               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12117               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12118     case EM_IP2K_OLD:
12119     case EM_IP2K:
12120       return reloc_type == 2; /* R_IP2K_32.  */
12121     case EM_IQ2000:
12122       return reloc_type == 2; /* R_IQ2000_32.  */
12123     case EM_LATTICEMICO32:
12124       return reloc_type == 3; /* R_LM32_32.  */
12125     case EM_M32C_OLD:
12126     case EM_M32C:
12127       return reloc_type == 3; /* R_M32C_32.  */
12128     case EM_M32R:
12129       return reloc_type == 34; /* R_M32R_32_RELA.  */
12130     case EM_68HC11:
12131     case EM_68HC12:
12132       return reloc_type == 6; /* R_M68HC11_32.  */
12133     case EM_MCORE:
12134       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12135     case EM_CYGNUS_MEP:
12136       return reloc_type == 4; /* R_MEP_32.  */
12137     case EM_METAG:
12138       return reloc_type == 2; /* R_METAG_ADDR32.  */
12139     case EM_MICROBLAZE:
12140       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12141     case EM_MIPS:
12142       return reloc_type == 2; /* R_MIPS_32.  */
12143     case EM_MMIX:
12144       return reloc_type == 4; /* R_MMIX_32.  */
12145     case EM_CYGNUS_MN10200:
12146     case EM_MN10200:
12147       return reloc_type == 1; /* R_MN10200_32.  */
12148     case EM_CYGNUS_MN10300:
12149     case EM_MN10300:
12150       return reloc_type == 1; /* R_MN10300_32.  */
12151     case EM_MOXIE:
12152       return reloc_type == 1; /* R_MOXIE_32.  */
12153     case EM_MSP430_OLD:
12154     case EM_MSP430:
12155       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12156     case EM_MT:
12157       return reloc_type == 2; /* R_MT_32.  */
12158     case EM_NDS32:
12159       return reloc_type == 20; /* R_NDS32_RELA.  */
12160     case EM_ALTERA_NIOS2:
12161       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12162     case EM_NIOS32:
12163       return reloc_type == 1; /* R_NIOS_32.  */
12164     case EM_OR1K:
12165       return reloc_type == 1; /* R_OR1K_32.  */
12166     case EM_PARISC:
12167       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12168               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12169     case EM_PJ:
12170     case EM_PJ_OLD:
12171       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12172     case EM_PPC64:
12173       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12174     case EM_PPC:
12175       return reloc_type == 1; /* R_PPC_ADDR32.  */
12176     case EM_TI_PRU:
12177       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12178     case EM_RISCV:
12179       return reloc_type == 1; /* R_RISCV_32.  */
12180     case EM_RL78:
12181       return reloc_type == 1; /* R_RL78_DIR32.  */
12182     case EM_RX:
12183       return reloc_type == 1; /* R_RX_DIR32.  */
12184     case EM_S370:
12185       return reloc_type == 1; /* R_I370_ADDR31.  */
12186     case EM_S390_OLD:
12187     case EM_S390:
12188       return reloc_type == 4; /* R_S390_32.  */
12189     case EM_SCORE:
12190       return reloc_type == 8; /* R_SCORE_ABS32.  */
12191     case EM_SH:
12192       return reloc_type == 1; /* R_SH_DIR32.  */
12193     case EM_SPARC32PLUS:
12194     case EM_SPARCV9:
12195     case EM_SPARC:
12196       return reloc_type == 3 /* R_SPARC_32.  */
12197         || reloc_type == 23; /* R_SPARC_UA32.  */
12198     case EM_SPU:
12199       return reloc_type == 6; /* R_SPU_ADDR32 */
12200     case EM_TI_C6000:
12201       return reloc_type == 1; /* R_C6000_ABS32.  */
12202     case EM_TILEGX:
12203       return reloc_type == 2; /* R_TILEGX_32.  */
12204     case EM_TILEPRO:
12205       return reloc_type == 1; /* R_TILEPRO_32.  */
12206     case EM_CYGNUS_V850:
12207     case EM_V850:
12208       return reloc_type == 6; /* R_V850_ABS32.  */
12209     case EM_V800:
12210       return reloc_type == 0x33; /* R_V810_WORD.  */
12211     case EM_VAX:
12212       return reloc_type == 1; /* R_VAX_32.  */
12213     case EM_VISIUM:
12214       return reloc_type == 3;  /* R_VISIUM_32. */
12215     case EM_WEBASSEMBLY:
12216       return reloc_type == 1;  /* R_WASM32_32.  */
12217     case EM_X86_64:
12218     case EM_L1OM:
12219     case EM_K1OM:
12220       return reloc_type == 10; /* R_X86_64_32.  */
12221     case EM_XC16X:
12222     case EM_C166:
12223       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12224     case EM_XGATE:
12225       return reloc_type == 4; /* R_XGATE_32.  */
12226     case EM_XSTORMY16:
12227       return reloc_type == 1; /* R_XSTROMY16_32.  */
12228     case EM_XTENSA_OLD:
12229     case EM_XTENSA:
12230       return reloc_type == 1; /* R_XTENSA_32.  */
12231     default:
12232       {
12233         static unsigned int prev_warn = 0;
12234
12235         /* Avoid repeating the same warning multiple times.  */
12236         if (prev_warn != elf_header.e_machine)
12237           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12238                  elf_header.e_machine);
12239         prev_warn = elf_header.e_machine;
12240         return FALSE;
12241       }
12242     }
12243 }
12244
12245 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12246    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12247
12248 static bfd_boolean
12249 is_32bit_pcrel_reloc (unsigned int reloc_type)
12250 {
12251   switch (elf_header.e_machine)
12252   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12253     {
12254     case EM_386:
12255     case EM_IAMCU:
12256       return reloc_type == 2;  /* R_386_PC32.  */
12257     case EM_68K:
12258       return reloc_type == 4;  /* R_68K_PC32.  */
12259     case EM_AARCH64:
12260       return reloc_type == 261; /* R_AARCH64_PREL32 */
12261     case EM_ADAPTEVA_EPIPHANY:
12262       return reloc_type == 6;
12263     case EM_ALPHA:
12264       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12265     case EM_ARC_COMPACT:
12266     case EM_ARC_COMPACT2:
12267       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12268     case EM_ARM:
12269       return reloc_type == 3;  /* R_ARM_REL32 */
12270     case EM_AVR_OLD:
12271     case EM_AVR:
12272       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12273     case EM_MICROBLAZE:
12274       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12275     case EM_OR1K:
12276       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12277     case EM_PARISC:
12278       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12279     case EM_PPC:
12280       return reloc_type == 26; /* R_PPC_REL32.  */
12281     case EM_PPC64:
12282       return reloc_type == 26; /* R_PPC64_REL32.  */
12283     case EM_S390_OLD:
12284     case EM_S390:
12285       return reloc_type == 5;  /* R_390_PC32.  */
12286     case EM_SH:
12287       return reloc_type == 2;  /* R_SH_REL32.  */
12288     case EM_SPARC32PLUS:
12289     case EM_SPARCV9:
12290     case EM_SPARC:
12291       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12292     case EM_SPU:
12293       return reloc_type == 13; /* R_SPU_REL32.  */
12294     case EM_TILEGX:
12295       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12296     case EM_TILEPRO:
12297       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12298     case EM_VISIUM:
12299       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12300     case EM_X86_64:
12301     case EM_L1OM:
12302     case EM_K1OM:
12303       return reloc_type == 2;  /* R_X86_64_PC32.  */
12304     case EM_XTENSA_OLD:
12305     case EM_XTENSA:
12306       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12307     default:
12308       /* Do not abort or issue an error message here.  Not all targets use
12309          pc-relative 32-bit relocs in their DWARF debug information and we
12310          have already tested for target coverage in is_32bit_abs_reloc.  A
12311          more helpful warning message will be generated by apply_relocations
12312          anyway, so just return.  */
12313       return FALSE;
12314     }
12315 }
12316
12317 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12318    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12319
12320 static bfd_boolean
12321 is_64bit_abs_reloc (unsigned int reloc_type)
12322 {
12323   switch (elf_header.e_machine)
12324     {
12325     case EM_AARCH64:
12326       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12327     case EM_ALPHA:
12328       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12329     case EM_IA_64:
12330       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12331               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12332     case EM_PARISC:
12333       return reloc_type == 80; /* R_PARISC_DIR64.  */
12334     case EM_PPC64:
12335       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12336     case EM_RISCV:
12337       return reloc_type == 2; /* R_RISCV_64.  */
12338     case EM_SPARC32PLUS:
12339     case EM_SPARCV9:
12340     case EM_SPARC:
12341       return reloc_type == 32 /* R_SPARC_64.  */
12342         || reloc_type == 54; /* R_SPARC_UA64.  */
12343     case EM_X86_64:
12344     case EM_L1OM:
12345     case EM_K1OM:
12346       return reloc_type == 1; /* R_X86_64_64.  */
12347     case EM_S390_OLD:
12348     case EM_S390:
12349       return reloc_type == 22;  /* R_S390_64.  */
12350     case EM_TILEGX:
12351       return reloc_type == 1; /* R_TILEGX_64.  */
12352     case EM_MIPS:
12353       return reloc_type == 18;  /* R_MIPS_64.  */
12354     default:
12355       return FALSE;
12356     }
12357 }
12358
12359 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12360    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12361
12362 static bfd_boolean
12363 is_64bit_pcrel_reloc (unsigned int reloc_type)
12364 {
12365   switch (elf_header.e_machine)
12366     {
12367     case EM_AARCH64:
12368       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12369     case EM_ALPHA:
12370       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12371     case EM_IA_64:
12372       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12373               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12374     case EM_PARISC:
12375       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12376     case EM_PPC64:
12377       return reloc_type == 44; /* R_PPC64_REL64.  */
12378     case EM_SPARC32PLUS:
12379     case EM_SPARCV9:
12380     case EM_SPARC:
12381       return reloc_type == 46; /* R_SPARC_DISP64.  */
12382     case EM_X86_64:
12383     case EM_L1OM:
12384     case EM_K1OM:
12385       return reloc_type == 24; /* R_X86_64_PC64.  */
12386     case EM_S390_OLD:
12387     case EM_S390:
12388       return reloc_type == 23;  /* R_S390_PC64.  */
12389     case EM_TILEGX:
12390       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12391     default:
12392       return FALSE;
12393     }
12394 }
12395
12396 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12397    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12398
12399 static bfd_boolean
12400 is_24bit_abs_reloc (unsigned int reloc_type)
12401 {
12402   switch (elf_header.e_machine)
12403     {
12404     case EM_CYGNUS_MN10200:
12405     case EM_MN10200:
12406       return reloc_type == 4; /* R_MN10200_24.  */
12407     case EM_FT32:
12408       return reloc_type == 5; /* R_FT32_20.  */
12409     default:
12410       return FALSE;
12411     }
12412 }
12413
12414 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12415    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12416
12417 static bfd_boolean
12418 is_16bit_abs_reloc (unsigned int reloc_type)
12419 {
12420   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12421   switch (elf_header.e_machine)
12422     {
12423     case EM_ARC:
12424     case EM_ARC_COMPACT:
12425     case EM_ARC_COMPACT2:
12426       return reloc_type == 2; /* R_ARC_16.  */
12427     case EM_ADAPTEVA_EPIPHANY:
12428       return reloc_type == 5;
12429     case EM_AVR_OLD:
12430     case EM_AVR:
12431       return reloc_type == 4; /* R_AVR_16.  */
12432     case EM_CYGNUS_D10V:
12433     case EM_D10V:
12434       return reloc_type == 3; /* R_D10V_16.  */
12435     case EM_H8S:
12436     case EM_H8_300:
12437     case EM_H8_300H:
12438       return reloc_type == R_H8_DIR16;
12439     case EM_IP2K_OLD:
12440     case EM_IP2K:
12441       return reloc_type == 1; /* R_IP2K_16.  */
12442     case EM_M32C_OLD:
12443     case EM_M32C:
12444       return reloc_type == 1; /* R_M32C_16 */
12445     case EM_CYGNUS_MN10200:
12446     case EM_MN10200:
12447       return reloc_type == 2; /* R_MN10200_16.  */
12448     case EM_CYGNUS_MN10300:
12449     case EM_MN10300:
12450       return reloc_type == 2; /* R_MN10300_16.  */
12451     case EM_MSP430:
12452       if (uses_msp430x_relocs ())
12453         return reloc_type == 2; /* R_MSP430_ABS16.  */
12454       /* Fall through.  */
12455     case EM_MSP430_OLD:
12456       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12457     case EM_NDS32:
12458       return reloc_type == 19; /* R_NDS32_RELA.  */
12459     case EM_ALTERA_NIOS2:
12460       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12461     case EM_NIOS32:
12462       return reloc_type == 9; /* R_NIOS_16.  */
12463     case EM_OR1K:
12464       return reloc_type == 2; /* R_OR1K_16.  */
12465     case EM_TI_PRU:
12466       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12467     case EM_TI_C6000:
12468       return reloc_type == 2; /* R_C6000_ABS16.  */
12469     case EM_VISIUM:
12470       return reloc_type == 2; /* R_VISIUM_16. */
12471     case EM_XC16X:
12472     case EM_C166:
12473       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12474     case EM_XGATE:
12475       return reloc_type == 3; /* R_XGATE_16.  */
12476     default:
12477       return FALSE;
12478     }
12479 }
12480
12481 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12482    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12483
12484 static bfd_boolean
12485 is_none_reloc (unsigned int reloc_type)
12486 {
12487   switch (elf_header.e_machine)
12488     {
12489     case EM_386:     /* R_386_NONE.  */
12490     case EM_68K:     /* R_68K_NONE.  */
12491     case EM_ADAPTEVA_EPIPHANY:
12492     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12493     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12494     case EM_ARC:     /* R_ARC_NONE.  */
12495     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12496     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12497     case EM_ARM:     /* R_ARM_NONE.  */
12498     case EM_C166:    /* R_XC16X_NONE.  */
12499     case EM_CRIS:    /* R_CRIS_NONE.  */
12500     case EM_FT32:    /* R_FT32_NONE.  */
12501     case EM_IA_64:   /* R_IA64_NONE.  */
12502     case EM_K1OM:    /* R_X86_64_NONE.  */
12503     case EM_L1OM:    /* R_X86_64_NONE.  */
12504     case EM_M32R:    /* R_M32R_NONE.  */
12505     case EM_MIPS:    /* R_MIPS_NONE.  */
12506     case EM_MN10300: /* R_MN10300_NONE.  */
12507     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12508     case EM_NIOS32:  /* R_NIOS_NONE.  */
12509     case EM_OR1K:    /* R_OR1K_NONE. */
12510     case EM_PARISC:  /* R_PARISC_NONE.  */
12511     case EM_PPC64:   /* R_PPC64_NONE.  */
12512     case EM_PPC:     /* R_PPC_NONE.  */
12513     case EM_RISCV:   /* R_RISCV_NONE.  */
12514     case EM_S390:    /* R_390_NONE.  */
12515     case EM_S390_OLD:
12516     case EM_SH:      /* R_SH_NONE.  */
12517     case EM_SPARC32PLUS:
12518     case EM_SPARC:   /* R_SPARC_NONE.  */
12519     case EM_SPARCV9:
12520     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12521     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12522     case EM_TI_C6000:/* R_C6000_NONE.  */
12523     case EM_X86_64:  /* R_X86_64_NONE.  */
12524     case EM_XC16X:
12525     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12526       return reloc_type == 0;
12527
12528     case EM_AARCH64:
12529       return reloc_type == 0 || reloc_type == 256;
12530     case EM_AVR_OLD:
12531     case EM_AVR:
12532       return (reloc_type == 0 /* R_AVR_NONE.  */
12533               || reloc_type == 30 /* R_AVR_DIFF8.  */
12534               || reloc_type == 31 /* R_AVR_DIFF16.  */
12535               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12536     case EM_METAG:
12537       return reloc_type == 3; /* R_METAG_NONE.  */
12538     case EM_NDS32:
12539       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12540               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12541               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12542               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12543               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12544     case EM_TI_PRU:
12545       return (reloc_type == 0       /* R_PRU_NONE.  */
12546               || reloc_type == 65   /* R_PRU_DIFF8.  */
12547               || reloc_type == 66   /* R_PRU_DIFF16.  */
12548               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12549     case EM_XTENSA_OLD:
12550     case EM_XTENSA:
12551       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12552               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12553               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12554               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12555     }
12556   return FALSE;
12557 }
12558
12559 /* Returns TRUE if there is a relocation against
12560    section NAME at OFFSET bytes.  */
12561
12562 bfd_boolean
12563 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12564 {
12565   Elf_Internal_Rela * relocs;
12566   Elf_Internal_Rela * rp;
12567
12568   if (dsec == NULL || dsec->reloc_info == NULL)
12569     return FALSE;
12570
12571   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12572
12573   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12574     if (rp->r_offset == offset)
12575       return TRUE;
12576
12577    return FALSE;
12578 }
12579
12580 /* Apply relocations to a section.
12581    Returns TRUE upon success, FALSE otherwise.
12582    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12583    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12584    will be set to the number of relocs loaded.
12585
12586    Note: So far support has been added only for those relocations
12587    which can be found in debug sections. FIXME: Add support for
12588    more relocations ?  */
12589
12590 static bfd_boolean
12591 apply_relocations (void *                     file,
12592                    const Elf_Internal_Shdr *  section,
12593                    unsigned char *            start,
12594                    bfd_size_type              size,
12595                    void **                    relocs_return,
12596                    unsigned long *            num_relocs_return)
12597 {
12598   Elf_Internal_Shdr * relsec;
12599   unsigned char * end = start + size;
12600   bfd_boolean res = TRUE;
12601
12602   if (relocs_return != NULL)
12603     {
12604       * (Elf_Internal_Rela **) relocs_return = NULL;
12605       * num_relocs_return = 0;
12606     }
12607
12608   if (elf_header.e_type != ET_REL)
12609     /* No relocs to apply.  */
12610     return TRUE;
12611
12612   /* Find the reloc section associated with the section.  */
12613   for (relsec = section_headers;
12614        relsec < section_headers + elf_header.e_shnum;
12615        ++relsec)
12616     {
12617       bfd_boolean is_rela;
12618       unsigned long num_relocs;
12619       Elf_Internal_Rela * relocs;
12620       Elf_Internal_Rela * rp;
12621       Elf_Internal_Shdr * symsec;
12622       Elf_Internal_Sym * symtab;
12623       unsigned long num_syms;
12624       Elf_Internal_Sym * sym;
12625
12626       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12627           || relsec->sh_info >= elf_header.e_shnum
12628           || section_headers + relsec->sh_info != section
12629           || relsec->sh_size == 0
12630           || relsec->sh_link >= elf_header.e_shnum)
12631         continue;
12632
12633       is_rela = relsec->sh_type == SHT_RELA;
12634
12635       if (is_rela)
12636         {
12637           if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12638                                   relsec->sh_size, & relocs, & num_relocs))
12639             return FALSE;
12640         }
12641       else
12642         {
12643           if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12644                                  relsec->sh_size, & relocs, & num_relocs))
12645             return FALSE;
12646         }
12647
12648       /* SH uses RELA but uses in place value instead of the addend field.  */
12649       if (elf_header.e_machine == EM_SH)
12650         is_rela = FALSE;
12651
12652       symsec = section_headers + relsec->sh_link;
12653       if (symsec->sh_type != SHT_SYMTAB
12654           && symsec->sh_type != SHT_DYNSYM)
12655         return FALSE;
12656       symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12657
12658       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12659         {
12660           bfd_vma         addend;
12661           unsigned int    reloc_type;
12662           unsigned int    reloc_size;
12663           unsigned char * rloc;
12664           unsigned long   sym_index;
12665
12666           reloc_type = get_reloc_type (rp->r_info);
12667
12668           if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12669             continue;
12670           else if (is_none_reloc (reloc_type))
12671             continue;
12672           else if (is_32bit_abs_reloc (reloc_type)
12673                    || is_32bit_pcrel_reloc (reloc_type))
12674             reloc_size = 4;
12675           else if (is_64bit_abs_reloc (reloc_type)
12676                    || is_64bit_pcrel_reloc (reloc_type))
12677             reloc_size = 8;
12678           else if (is_24bit_abs_reloc (reloc_type))
12679             reloc_size = 3;
12680           else if (is_16bit_abs_reloc (reloc_type))
12681             reloc_size = 2;
12682           else
12683             {
12684               static unsigned int prev_reloc = 0;
12685               if (reloc_type != prev_reloc)
12686                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12687                       reloc_type, printable_section_name (section));
12688               prev_reloc = reloc_type;
12689               res = FALSE;
12690               continue;
12691             }
12692
12693           rloc = start + rp->r_offset;
12694           if ((rloc + reloc_size) > end || (rloc < start))
12695             {
12696               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12697                     (unsigned long) rp->r_offset,
12698                     printable_section_name (section));
12699               res = FALSE;
12700               continue;
12701             }
12702
12703           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12704           if (sym_index >= num_syms)
12705             {
12706               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12707                     sym_index, printable_section_name (section));
12708               res = FALSE;
12709               continue;
12710             }
12711           sym = symtab + sym_index;
12712
12713           /* If the reloc has a symbol associated with it,
12714              make sure that it is of an appropriate type.
12715
12716              Relocations against symbols without type can happen.
12717              Gcc -feliminate-dwarf2-dups may generate symbols
12718              without type for debug info.
12719
12720              Icc generates relocations against function symbols
12721              instead of local labels.
12722
12723              Relocations against object symbols can happen, eg when
12724              referencing a global array.  For an example of this see
12725              the _clz.o binary in libgcc.a.  */
12726           if (sym != symtab
12727               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12728               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12729             {
12730               warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12731                     get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12732                     (long int)(rp - relocs),
12733                     printable_section_name (relsec));
12734               res = FALSE;
12735               continue;
12736             }
12737
12738           addend = 0;
12739           if (is_rela)
12740             addend += rp->r_addend;
12741           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12742              partial_inplace.  */
12743           if (!is_rela
12744               || (elf_header.e_machine == EM_XTENSA
12745                   && reloc_type == 1)
12746               || ((elf_header.e_machine == EM_PJ
12747                    || elf_header.e_machine == EM_PJ_OLD)
12748                   && reloc_type == 1)
12749               || ((elf_header.e_machine == EM_D30V
12750                    || elf_header.e_machine == EM_CYGNUS_D30V)
12751                   && reloc_type == 12))
12752             addend += byte_get (rloc, reloc_size);
12753
12754           if (is_32bit_pcrel_reloc (reloc_type)
12755               || is_64bit_pcrel_reloc (reloc_type))
12756             {
12757               /* On HPPA, all pc-relative relocations are biased by 8.  */
12758               if (elf_header.e_machine == EM_PARISC)
12759                 addend -= 8;
12760               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12761                         reloc_size);
12762             }
12763           else
12764             byte_put (rloc, addend + sym->st_value, reloc_size);
12765         }
12766
12767       free (symtab);
12768       /* Let the target specific reloc processing code know that
12769          we have finished with these relocs.  */
12770       target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12771
12772       if (relocs_return)
12773         {
12774           * (Elf_Internal_Rela **) relocs_return = relocs;
12775           * num_relocs_return = num_relocs;
12776         }
12777       else
12778         free (relocs);
12779
12780       break;
12781     }
12782
12783   return res;
12784 }
12785
12786 #ifdef SUPPORT_DISASSEMBLY
12787 static bfd_boolean
12788 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12789 {
12790   printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12791
12792   /* FIXME: XXX -- to be done --- XXX */
12793
12794   return TRUE;
12795 }
12796 #endif
12797
12798 /* Reads in the contents of SECTION from FILE, returning a pointer
12799    to a malloc'ed buffer or NULL if something went wrong.  */
12800
12801 static char *
12802 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12803 {
12804   bfd_size_type num_bytes;
12805
12806   num_bytes = section->sh_size;
12807
12808   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12809     {
12810       printf (_("Section '%s' has no data to dump.\n"),
12811               printable_section_name (section));
12812       return NULL;
12813     }
12814
12815   return  (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12816                              _("section contents"));
12817 }
12818
12819 /* Uncompresses a section that was compressed using zlib, in place.  */
12820
12821 static bfd_boolean
12822 uncompress_section_contents (unsigned char **buffer,
12823                              dwarf_size_type uncompressed_size,
12824                              dwarf_size_type *size)
12825 {
12826   dwarf_size_type compressed_size = *size;
12827   unsigned char * compressed_buffer = *buffer;
12828   unsigned char * uncompressed_buffer;
12829   z_stream strm;
12830   int rc;
12831
12832   /* It is possible the section consists of several compressed
12833      buffers concatenated together, so we uncompress in a loop.  */
12834   /* PR 18313: The state field in the z_stream structure is supposed
12835      to be invisible to the user (ie us), but some compilers will
12836      still complain about it being used without initialisation.  So
12837      we first zero the entire z_stream structure and then set the fields
12838      that we need.  */
12839   memset (& strm, 0, sizeof strm);
12840   strm.avail_in = compressed_size;
12841   strm.next_in = (Bytef *) compressed_buffer;
12842   strm.avail_out = uncompressed_size;
12843   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12844
12845   rc = inflateInit (& strm);
12846   while (strm.avail_in > 0)
12847     {
12848       if (rc != Z_OK)
12849         goto fail;
12850       strm.next_out = ((Bytef *) uncompressed_buffer
12851                        + (uncompressed_size - strm.avail_out));
12852       rc = inflate (&strm, Z_FINISH);
12853       if (rc != Z_STREAM_END)
12854         goto fail;
12855       rc = inflateReset (& strm);
12856     }
12857   rc = inflateEnd (& strm);
12858   if (rc != Z_OK
12859       || strm.avail_out != 0)
12860     goto fail;
12861
12862   *buffer = uncompressed_buffer;
12863   *size = uncompressed_size;
12864   return TRUE;
12865
12866  fail:
12867   free (uncompressed_buffer);
12868   /* Indicate decompression failure.  */
12869   *buffer = NULL;
12870   return FALSE;
12871 }
12872
12873 static bfd_boolean
12874 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12875 {
12876   Elf_Internal_Shdr *  relsec;
12877   bfd_size_type        num_bytes;
12878   unsigned char *      data;
12879   unsigned char *      end;
12880   unsigned char *      real_start;
12881   unsigned char *      start;
12882   bfd_boolean          some_strings_shown;
12883
12884   real_start = start = (unsigned char *) get_section_contents (section, file);
12885   if (start == NULL)
12886     /* PR 21820: Do not fail if the section was empty.  */
12887     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12888
12889   num_bytes = section->sh_size;
12890
12891   printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12892
12893   if (decompress_dumps)
12894     {
12895       dwarf_size_type new_size = num_bytes;
12896       dwarf_size_type uncompressed_size = 0;
12897
12898       if ((section->sh_flags & SHF_COMPRESSED) != 0)
12899         {
12900           Elf_Internal_Chdr chdr;
12901           unsigned int compression_header_size
12902             = get_compression_header (& chdr, (unsigned char *) start,
12903                                       num_bytes);
12904
12905           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12906             {
12907               warn (_("section '%s' has unsupported compress type: %d\n"),
12908                     printable_section_name (section), chdr.ch_type);
12909               return FALSE;
12910             }
12911           else if (chdr.ch_addralign != section->sh_addralign)
12912             {
12913               warn (_("compressed section '%s' is corrupted\n"),
12914                     printable_section_name (section));
12915               return FALSE;
12916             }
12917           uncompressed_size = chdr.ch_size;
12918           start += compression_header_size;
12919           new_size -= compression_header_size;
12920         }
12921       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12922         {
12923           /* Read the zlib header.  In this case, it should be "ZLIB"
12924              followed by the uncompressed section size, 8 bytes in
12925              big-endian order.  */
12926           uncompressed_size = start[4]; uncompressed_size <<= 8;
12927           uncompressed_size += start[5]; uncompressed_size <<= 8;
12928           uncompressed_size += start[6]; uncompressed_size <<= 8;
12929           uncompressed_size += start[7]; uncompressed_size <<= 8;
12930           uncompressed_size += start[8]; uncompressed_size <<= 8;
12931           uncompressed_size += start[9]; uncompressed_size <<= 8;
12932           uncompressed_size += start[10]; uncompressed_size <<= 8;
12933           uncompressed_size += start[11];
12934           start += 12;
12935           new_size -= 12;
12936         }
12937
12938       if (uncompressed_size)
12939         {
12940           if (uncompress_section_contents (& start,
12941                                            uncompressed_size, & new_size))
12942             num_bytes = new_size;
12943           else
12944             {
12945               error (_("Unable to decompress section %s\n"),
12946                      printable_section_name (section));
12947               return FALSE;
12948             }
12949         }
12950       else
12951         start = real_start;
12952     }
12953
12954   /* If the section being dumped has relocations against it the user might
12955      be expecting these relocations to have been applied.  Check for this
12956      case and issue a warning message in order to avoid confusion.
12957      FIXME: Maybe we ought to have an option that dumps a section with
12958      relocs applied ?  */
12959   for (relsec = section_headers;
12960        relsec < section_headers + elf_header.e_shnum;
12961        ++relsec)
12962     {
12963       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12964           || relsec->sh_info >= elf_header.e_shnum
12965           || section_headers + relsec->sh_info != section
12966           || relsec->sh_size == 0
12967           || relsec->sh_link >= elf_header.e_shnum)
12968         continue;
12969
12970       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12971       break;
12972     }
12973
12974   data = start;
12975   end  = start + num_bytes;
12976   some_strings_shown = FALSE;
12977
12978   while (data < end)
12979     {
12980       while (!ISPRINT (* data))
12981         if (++ data >= end)
12982           break;
12983
12984       if (data < end)
12985         {
12986           size_t maxlen = end - data;
12987
12988 #ifndef __MSVCRT__
12989           /* PR 11128: Use two separate invocations in order to work
12990              around bugs in the Solaris 8 implementation of printf.  */
12991           printf ("  [%6tx]  ", data - start);
12992 #else
12993           printf ("  [%6Ix]  ", (size_t) (data - start));
12994 #endif
12995           if (maxlen > 0)
12996             {
12997               print_symbol ((int) maxlen, (const char *) data);
12998               putchar ('\n');
12999               data += strnlen ((const char *) data, maxlen);
13000             }
13001           else
13002             {
13003               printf (_("<corrupt>\n"));
13004               data = end;
13005             }
13006           some_strings_shown = TRUE;
13007         }
13008     }
13009
13010   if (! some_strings_shown)
13011     printf (_("  No strings found in this section."));
13012
13013   free (real_start);
13014
13015   putchar ('\n');
13016   return TRUE;
13017 }
13018
13019 static bfd_boolean
13020 dump_section_as_bytes (Elf_Internal_Shdr * section,
13021                        FILE * file,
13022                        bfd_boolean relocate)
13023 {
13024   Elf_Internal_Shdr * relsec;
13025   bfd_size_type       bytes;
13026   bfd_size_type       section_size;
13027   bfd_vma             addr;
13028   unsigned char *     data;
13029   unsigned char *     real_start;
13030   unsigned char *     start;
13031
13032   real_start = start = (unsigned char *) get_section_contents (section, file);
13033   if (start == NULL)
13034     /* PR 21820: Do not fail if the section was empty.  */
13035     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13036
13037   section_size = section->sh_size;
13038
13039   printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
13040
13041   if (decompress_dumps)
13042     {
13043       dwarf_size_type new_size = section_size;
13044       dwarf_size_type uncompressed_size = 0;
13045
13046       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13047         {
13048           Elf_Internal_Chdr chdr;
13049           unsigned int compression_header_size
13050             = get_compression_header (& chdr, start, section_size);
13051
13052           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13053             {
13054               warn (_("section '%s' has unsupported compress type: %d\n"),
13055                     printable_section_name (section), chdr.ch_type);
13056               return FALSE;
13057             }
13058           else if (chdr.ch_addralign != section->sh_addralign)
13059             {
13060               warn (_("compressed section '%s' is corrupted\n"),
13061                     printable_section_name (section));
13062               return FALSE;
13063             }
13064           uncompressed_size = chdr.ch_size;
13065           start += compression_header_size;
13066           new_size -= compression_header_size;
13067         }
13068       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13069         {
13070           /* Read the zlib header.  In this case, it should be "ZLIB"
13071              followed by the uncompressed section size, 8 bytes in
13072              big-endian order.  */
13073           uncompressed_size = start[4]; uncompressed_size <<= 8;
13074           uncompressed_size += start[5]; uncompressed_size <<= 8;
13075           uncompressed_size += start[6]; uncompressed_size <<= 8;
13076           uncompressed_size += start[7]; uncompressed_size <<= 8;
13077           uncompressed_size += start[8]; uncompressed_size <<= 8;
13078           uncompressed_size += start[9]; uncompressed_size <<= 8;
13079           uncompressed_size += start[10]; uncompressed_size <<= 8;
13080           uncompressed_size += start[11];
13081           start += 12;
13082           new_size -= 12;
13083         }
13084
13085       if (uncompressed_size)
13086         {
13087           if (uncompress_section_contents (& start, uncompressed_size,
13088                                            & new_size))
13089             {
13090               section_size = new_size;
13091             }
13092           else
13093             {
13094               error (_("Unable to decompress section %s\n"),
13095                      printable_section_name (section));
13096               /* FIXME: Print the section anyway ?  */
13097               return FALSE;
13098             }
13099         }
13100       else
13101         start = real_start;
13102     }
13103
13104   if (relocate)
13105     {
13106       if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13107         return FALSE;
13108     }
13109   else
13110     {
13111       /* If the section being dumped has relocations against it the user might
13112          be expecting these relocations to have been applied.  Check for this
13113          case and issue a warning message in order to avoid confusion.
13114          FIXME: Maybe we ought to have an option that dumps a section with
13115          relocs applied ?  */
13116       for (relsec = section_headers;
13117            relsec < section_headers + elf_header.e_shnum;
13118            ++relsec)
13119         {
13120           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13121               || relsec->sh_info >= elf_header.e_shnum
13122               || section_headers + relsec->sh_info != section
13123               || relsec->sh_size == 0
13124               || relsec->sh_link >= elf_header.e_shnum)
13125             continue;
13126
13127           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13128           break;
13129         }
13130     }
13131
13132   addr = section->sh_addr;
13133   bytes = section_size;
13134   data = start;
13135
13136   while (bytes)
13137     {
13138       int j;
13139       int k;
13140       int lbytes;
13141
13142       lbytes = (bytes > 16 ? 16 : bytes);
13143
13144       printf ("  0x%8.8lx ", (unsigned long) addr);
13145
13146       for (j = 0; j < 16; j++)
13147         {
13148           if (j < lbytes)
13149             printf ("%2.2x", data[j]);
13150           else
13151             printf ("  ");
13152
13153           if ((j & 3) == 3)
13154             printf (" ");
13155         }
13156
13157       for (j = 0; j < lbytes; j++)
13158         {
13159           k = data[j];
13160           if (k >= ' ' && k < 0x7f)
13161             printf ("%c", k);
13162           else
13163             printf (".");
13164         }
13165
13166       putchar ('\n');
13167
13168       data  += lbytes;
13169       addr  += lbytes;
13170       bytes -= lbytes;
13171     }
13172
13173   free (real_start);
13174
13175   putchar ('\n');
13176   return TRUE;
13177 }
13178
13179 static bfd_boolean
13180 load_specific_debug_section (enum dwarf_section_display_enum debug,
13181                              const Elf_Internal_Shdr * sec, void * file)
13182 {
13183   struct dwarf_section * section = &debug_displays [debug].section;
13184   char buf [64];
13185
13186   /* If it is already loaded, do nothing.  */
13187   if (section->start != NULL)
13188     return TRUE;
13189
13190   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13191   section->address = sec->sh_addr;
13192   section->user_data = NULL;
13193   section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13194                                                sec->sh_offset, 1,
13195                                                sec->sh_size, buf);
13196   if (section->start == NULL)
13197     section->size = 0;
13198   else
13199     {
13200       unsigned char *start = section->start;
13201       dwarf_size_type size = sec->sh_size;
13202       dwarf_size_type uncompressed_size = 0;
13203
13204       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13205         {
13206           Elf_Internal_Chdr chdr;
13207           unsigned int compression_header_size;
13208
13209           if (size < (is_32bit_elf
13210                       ? sizeof (Elf32_External_Chdr)
13211                       : sizeof (Elf64_External_Chdr)))
13212             {
13213               warn (_("compressed section %s is too small to contain a compression header"),
13214                     section->name);
13215               return FALSE;
13216             }
13217
13218           compression_header_size = get_compression_header (&chdr, start, size);
13219
13220           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13221             {
13222               warn (_("section '%s' has unsupported compress type: %d\n"),
13223                     section->name, chdr.ch_type);
13224               return FALSE;
13225             }
13226           else if (chdr.ch_addralign != sec->sh_addralign)
13227             {
13228               warn (_("compressed section '%s' is corrupted\n"),
13229                     section->name);
13230               return FALSE;
13231             }
13232           uncompressed_size = chdr.ch_size;
13233           start += compression_header_size;
13234           size -= compression_header_size;
13235         }
13236       else if (size > 12 && streq ((char *) start, "ZLIB"))
13237         {
13238           /* Read the zlib header.  In this case, it should be "ZLIB"
13239              followed by the uncompressed section size, 8 bytes in
13240              big-endian order.  */
13241           uncompressed_size = start[4]; uncompressed_size <<= 8;
13242           uncompressed_size += start[5]; uncompressed_size <<= 8;
13243           uncompressed_size += start[6]; uncompressed_size <<= 8;
13244           uncompressed_size += start[7]; uncompressed_size <<= 8;
13245           uncompressed_size += start[8]; uncompressed_size <<= 8;
13246           uncompressed_size += start[9]; uncompressed_size <<= 8;
13247           uncompressed_size += start[10]; uncompressed_size <<= 8;
13248           uncompressed_size += start[11];
13249           start += 12;
13250           size -= 12;
13251         }
13252
13253       if (uncompressed_size)
13254         {
13255           if (uncompress_section_contents (&start, uncompressed_size,
13256                                            &size))
13257             {
13258               /* Free the compressed buffer, update the section buffer
13259                  and the section size if uncompress is successful.  */
13260               free (section->start);
13261               section->start = start;
13262             }
13263           else
13264             {
13265               error (_("Unable to decompress section %s\n"),
13266                      printable_section_name (sec));
13267               return FALSE;
13268             }
13269         }
13270
13271       section->size = size;
13272     }
13273
13274   if (section->start == NULL)
13275     return FALSE;
13276
13277   if (debug_displays [debug].relocate)
13278     {
13279       if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13280                                & section->reloc_info, & section->num_relocs))
13281         return FALSE;
13282     }
13283   else
13284     {
13285       section->reloc_info = NULL;
13286       section->num_relocs = 0;
13287     }
13288
13289   return TRUE;
13290 }
13291
13292 /* If this is not NULL, load_debug_section will only look for sections
13293    within the list of sections given here.  */
13294 static unsigned int * section_subset = NULL;
13295
13296 bfd_boolean
13297 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13298 {
13299   struct dwarf_section * section = &debug_displays [debug].section;
13300   Elf_Internal_Shdr * sec;
13301
13302   /* Locate the debug section.  */
13303   sec = find_section_in_set (section->uncompressed_name, section_subset);
13304   if (sec != NULL)
13305     section->name = section->uncompressed_name;
13306   else
13307     {
13308       sec = find_section_in_set (section->compressed_name, section_subset);
13309       if (sec != NULL)
13310         section->name = section->compressed_name;
13311     }
13312   if (sec == NULL)
13313     return FALSE;
13314
13315   /* If we're loading from a subset of sections, and we've loaded
13316      a section matching this name before, it's likely that it's a
13317      different one.  */
13318   if (section_subset != NULL)
13319     free_debug_section (debug);
13320
13321   return load_specific_debug_section (debug, sec, (FILE *) file);
13322 }
13323
13324 void
13325 free_debug_section (enum dwarf_section_display_enum debug)
13326 {
13327   struct dwarf_section * section = &debug_displays [debug].section;
13328
13329   if (section->start == NULL)
13330     return;
13331
13332   free ((char *) section->start);
13333   section->start = NULL;
13334   section->address = 0;
13335   section->size = 0;
13336 }
13337
13338 static bfd_boolean
13339 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13340 {
13341   char * name = SECTION_NAME (section);
13342   const char * print_name = printable_section_name (section);
13343   bfd_size_type length;
13344   bfd_boolean result = TRUE;
13345   int i;
13346
13347   length = section->sh_size;
13348   if (length == 0)
13349     {
13350       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13351       return TRUE;
13352     }
13353   if (section->sh_type == SHT_NOBITS)
13354     {
13355       /* There is no point in dumping the contents of a debugging section
13356          which has the NOBITS type - the bits in the file will be random.
13357          This can happen when a file containing a .eh_frame section is
13358          stripped with the --only-keep-debug command line option.  */
13359       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13360               print_name);
13361       return FALSE;
13362     }
13363
13364   if (const_strneq (name, ".gnu.linkonce.wi."))
13365     name = ".debug_info";
13366
13367   /* See if we know how to display the contents of this section.  */
13368   for (i = 0; i < max; i++)
13369     if (streq (debug_displays[i].section.uncompressed_name, name)
13370         || (i == line && const_strneq (name, ".debug_line."))
13371         || streq (debug_displays[i].section.compressed_name, name))
13372       {
13373         struct dwarf_section * sec = &debug_displays [i].section;
13374         int secondary = (section != find_section (name));
13375
13376         if (secondary)
13377           free_debug_section ((enum dwarf_section_display_enum) i);
13378
13379         if (i == line && const_strneq (name, ".debug_line."))
13380           sec->name = name;
13381         else if (streq (sec->uncompressed_name, name))
13382           sec->name = sec->uncompressed_name;
13383         else
13384           sec->name = sec->compressed_name;
13385         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13386                                          section, file))
13387           {
13388             /* If this debug section is part of a CU/TU set in a .dwp file,
13389                restrict load_debug_section to the sections in that set.  */
13390             section_subset = find_cu_tu_set (file, shndx);
13391
13392             result &= debug_displays[i].display (sec, file);
13393
13394             section_subset = NULL;
13395
13396             if (secondary || (i != info && i != abbrev))
13397               free_debug_section ((enum dwarf_section_display_enum) i);
13398           }
13399
13400         break;
13401       }
13402
13403   if (i == max)
13404     {
13405       printf (_("Unrecognized debug section: %s\n"), print_name);
13406       result = FALSE;
13407     }
13408
13409   return result;
13410 }
13411
13412 /* Set DUMP_SECTS for all sections where dumps were requested
13413    based on section name.  */
13414
13415 static void
13416 initialise_dumps_byname (void)
13417 {
13418   struct dump_list_entry * cur;
13419
13420   for (cur = dump_sects_byname; cur; cur = cur->next)
13421     {
13422       unsigned int i;
13423       bfd_boolean any = FALSE;
13424
13425       for (i = 0; i < elf_header.e_shnum; i++)
13426         if (streq (SECTION_NAME (section_headers + i), cur->name))
13427           {
13428             request_dump_bynumber (i, cur->type);
13429             any = TRUE;
13430           }
13431
13432       if (!any)
13433         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13434               cur->name);
13435     }
13436 }
13437
13438 static bfd_boolean
13439 process_section_contents (FILE * file)
13440 {
13441   Elf_Internal_Shdr * section;
13442   unsigned int i;
13443   bfd_boolean res = TRUE;
13444
13445   if (! do_dump)
13446     return TRUE;
13447
13448   initialise_dumps_byname ();
13449
13450   for (i = 0, section = section_headers;
13451        i < elf_header.e_shnum && i < num_dump_sects;
13452        i++, section++)
13453     {
13454 #ifdef SUPPORT_DISASSEMBLY
13455       if (dump_sects[i] & DISASS_DUMP)
13456         disassemble_section (section, file);
13457 #endif
13458       if (dump_sects[i] & HEX_DUMP)
13459         {
13460           if (! dump_section_as_bytes (section, file, FALSE))
13461             res = FALSE;
13462         }
13463
13464       if (dump_sects[i] & RELOC_DUMP)
13465         {
13466           if (! dump_section_as_bytes (section, file, TRUE))
13467             res = FALSE;
13468         }
13469
13470       if (dump_sects[i] & STRING_DUMP)
13471         {
13472           if (! dump_section_as_strings (section, file))
13473             res = FALSE;
13474         }
13475
13476       if (dump_sects[i] & DEBUG_DUMP)
13477         {
13478           if (! display_debug_section (i, section, file))
13479             res = FALSE;
13480         }
13481     }
13482
13483   /* Check to see if the user requested a
13484      dump of a section that does not exist.  */
13485   while (i < num_dump_sects)
13486     {
13487       if (dump_sects[i])
13488         {
13489           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13490           res = FALSE;
13491         }
13492       i++;
13493     }
13494
13495   return res;
13496 }
13497
13498 static void
13499 process_mips_fpe_exception (int mask)
13500 {
13501   if (mask)
13502     {
13503       bfd_boolean first = TRUE;
13504
13505       if (mask & OEX_FPU_INEX)
13506         fputs ("INEX", stdout), first = FALSE;
13507       if (mask & OEX_FPU_UFLO)
13508         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13509       if (mask & OEX_FPU_OFLO)
13510         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13511       if (mask & OEX_FPU_DIV0)
13512         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13513       if (mask & OEX_FPU_INVAL)
13514         printf ("%sINVAL", first ? "" : "|");
13515     }
13516   else
13517     fputs ("0", stdout);
13518 }
13519
13520 /* Display's the value of TAG at location P.  If TAG is
13521    greater than 0 it is assumed to be an unknown tag, and
13522    a message is printed to this effect.  Otherwise it is
13523    assumed that a message has already been printed.
13524
13525    If the bottom bit of TAG is set it assumed to have a
13526    string value, otherwise it is assumed to have an integer
13527    value.
13528
13529    Returns an updated P pointing to the first unread byte
13530    beyond the end of TAG's value.
13531
13532    Reads at or beyond END will not be made.  */
13533
13534 static unsigned char *
13535 display_tag_value (signed int tag,
13536                    unsigned char * p,
13537                    const unsigned char * const end)
13538 {
13539   unsigned long val;
13540
13541   if (tag > 0)
13542     printf ("  Tag_unknown_%d: ", tag);
13543
13544   if (p >= end)
13545     {
13546       warn (_("<corrupt tag>\n"));
13547     }
13548   else if (tag & 1)
13549     {
13550       /* PR 17531 file: 027-19978-0.004.  */
13551       size_t maxlen = (end - p) - 1;
13552
13553       putchar ('"');
13554       if (maxlen > 0)
13555         {
13556           print_symbol ((int) maxlen, (const char *) p);
13557           p += strnlen ((char *) p, maxlen) + 1;
13558         }
13559       else
13560         {
13561           printf (_("<corrupt string tag>"));
13562           p = (unsigned char *) end;
13563         }
13564       printf ("\"\n");
13565     }
13566   else
13567     {
13568       unsigned int len;
13569
13570       val = read_uleb128 (p, &len, end);
13571       p += len;
13572       printf ("%ld (0x%lx)\n", val, val);
13573     }
13574
13575   assert (p <= end);
13576   return p;
13577 }
13578
13579 /* ARC ABI attributes section.  */
13580
13581 static unsigned char *
13582 display_arc_attribute (unsigned char * p,
13583                        const unsigned char * const end)
13584 {
13585   unsigned int tag;
13586   unsigned int len;
13587   unsigned int val;
13588
13589   tag = read_uleb128 (p, &len, end);
13590   p += len;
13591
13592   switch (tag)
13593     {
13594     case Tag_ARC_PCS_config:
13595       val = read_uleb128 (p, &len, end);
13596       p += len;
13597       printf ("  Tag_ARC_PCS_config: ");
13598       switch (val)
13599         {
13600         case 0:
13601           printf (_("Absent/Non standard\n"));
13602           break;
13603         case 1:
13604           printf (_("Bare metal/mwdt\n"));
13605           break;
13606         case 2:
13607           printf (_("Bare metal/newlib\n"));
13608           break;
13609         case 3:
13610           printf (_("Linux/uclibc\n"));
13611           break;
13612         case 4:
13613           printf (_("Linux/glibc\n"));
13614           break;
13615         default:
13616           printf (_("Unknown\n"));
13617           break;
13618         }
13619       break;
13620
13621     case Tag_ARC_CPU_base:
13622       val = read_uleb128 (p, &len, end);
13623       p += len;
13624       printf ("  Tag_ARC_CPU_base: ");
13625       switch (val)
13626         {
13627         default:
13628         case TAG_CPU_NONE:
13629           printf (_("Absent\n"));
13630           break;
13631         case TAG_CPU_ARC6xx:
13632           printf ("ARC6xx\n");
13633           break;
13634         case TAG_CPU_ARC7xx:
13635           printf ("ARC7xx\n");
13636           break;
13637         case TAG_CPU_ARCEM:
13638           printf ("ARCEM\n");
13639           break;
13640         case TAG_CPU_ARCHS:
13641           printf ("ARCHS\n");
13642           break;
13643         }
13644       break;
13645
13646     case Tag_ARC_CPU_variation:
13647       val = read_uleb128 (p, &len, end);
13648       p += len;
13649       printf ("  Tag_ARC_CPU_variation: ");
13650       switch (val)
13651         {
13652         default:
13653           if (val > 0 && val < 16)
13654               printf ("Core%d\n", val);
13655           else
13656               printf ("Unknown\n");
13657           break;
13658
13659         case 0:
13660           printf (_("Absent\n"));
13661           break;
13662         }
13663       break;
13664
13665     case Tag_ARC_CPU_name:
13666       printf ("  Tag_ARC_CPU_name: ");
13667       p = display_tag_value (-1, p, end);
13668       break;
13669
13670     case Tag_ARC_ABI_rf16:
13671       val = read_uleb128 (p, &len, end);
13672       p += len;
13673       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13674       break;
13675
13676     case Tag_ARC_ABI_osver:
13677       val = read_uleb128 (p, &len, end);
13678       p += len;
13679       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13680       break;
13681
13682     case Tag_ARC_ABI_pic:
13683     case Tag_ARC_ABI_sda:
13684       val = read_uleb128 (p, &len, end);
13685       p += len;
13686       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13687               : "  Tag_ARC_ABI_pic: ");
13688       switch (val)
13689         {
13690         case 0:
13691           printf (_("Absent\n"));
13692           break;
13693         case 1:
13694           printf ("MWDT\n");
13695           break;
13696         case 2:
13697           printf ("GNU\n");
13698           break;
13699         default:
13700           printf (_("Unknown\n"));
13701           break;
13702         }
13703       break;
13704
13705     case Tag_ARC_ABI_tls:
13706       val = read_uleb128 (p, &len, end);
13707       p += len;
13708       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13709       break;
13710
13711     case Tag_ARC_ABI_enumsize:
13712       val = read_uleb128 (p, &len, end);
13713       p += len;
13714       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13715               _("smallest"));
13716       break;
13717
13718     case Tag_ARC_ABI_exceptions:
13719       val = read_uleb128 (p, &len, end);
13720       p += len;
13721       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13722               : _("default"));
13723       break;
13724
13725     case Tag_ARC_ABI_double_size:
13726       val = read_uleb128 (p, &len, end);
13727       p += len;
13728       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
13729       break;
13730
13731     case Tag_ARC_ISA_config:
13732       printf ("  Tag_ARC_ISA_config: ");
13733       p = display_tag_value (-1, p, end);
13734       break;
13735
13736     case Tag_ARC_ISA_apex:
13737       printf ("  Tag_ARC_ISA_apex: ");
13738       p = display_tag_value (-1, p, end);
13739       break;
13740
13741     case Tag_ARC_ISA_mpy_option:
13742       val = read_uleb128 (p, &len, end);
13743       p += len;
13744       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
13745       break;
13746
13747     default:
13748       return display_tag_value (tag & 1, p, end);
13749     }
13750
13751   return p;
13752 }
13753
13754 /* ARM EABI attributes section.  */
13755 typedef struct
13756 {
13757   unsigned int tag;
13758   const char * name;
13759   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
13760   unsigned int type;
13761   const char ** table;
13762 } arm_attr_public_tag;
13763
13764 static const char * arm_attr_tag_CPU_arch[] =
13765   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13766    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13767    "v8-M.mainline"};
13768 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13769 static const char * arm_attr_tag_THUMB_ISA_use[] =
13770   {"No", "Thumb-1", "Thumb-2", "Yes"};
13771 static const char * arm_attr_tag_FP_arch[] =
13772   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13773    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13774 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13775 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13776   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13777    "NEON for ARMv8.1"};
13778 static const char * arm_attr_tag_PCS_config[] =
13779   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13780    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13781 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13782   {"V6", "SB", "TLS", "Unused"};
13783 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13784   {"Absolute", "PC-relative", "SB-relative", "None"};
13785 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13786   {"Absolute", "PC-relative", "None"};
13787 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13788   {"None", "direct", "GOT-indirect"};
13789 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13790   {"None", "??? 1", "2", "??? 3", "4"};
13791 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13792 static const char * arm_attr_tag_ABI_FP_denormal[] =
13793   {"Unused", "Needed", "Sign only"};
13794 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13795 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13796 static const char * arm_attr_tag_ABI_FP_number_model[] =
13797   {"Unused", "Finite", "RTABI", "IEEE 754"};
13798 static const char * arm_attr_tag_ABI_enum_size[] =
13799   {"Unused", "small", "int", "forced to int"};
13800 static const char * arm_attr_tag_ABI_HardFP_use[] =
13801   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13802 static const char * arm_attr_tag_ABI_VFP_args[] =
13803   {"AAPCS", "VFP registers", "custom", "compatible"};
13804 static const char * arm_attr_tag_ABI_WMMX_args[] =
13805   {"AAPCS", "WMMX registers", "custom"};
13806 static const char * arm_attr_tag_ABI_optimization_goals[] =
13807   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13808     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13809 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13810   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13811     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13812 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13813 static const char * arm_attr_tag_FP_HP_extension[] =
13814   {"Not Allowed", "Allowed"};
13815 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13816   {"None", "IEEE 754", "Alternative Format"};
13817 static const char * arm_attr_tag_DSP_extension[] =
13818   {"Follow architecture", "Allowed"};
13819 static const char * arm_attr_tag_MPextension_use[] =
13820   {"Not Allowed", "Allowed"};
13821 static const char * arm_attr_tag_DIV_use[] =
13822   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13823     "Allowed in v7-A with integer division extension"};
13824 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13825 static const char * arm_attr_tag_Virtualization_use[] =
13826   {"Not Allowed", "TrustZone", "Virtualization Extensions",
13827     "TrustZone and Virtualization Extensions"};
13828 static const char * arm_attr_tag_MPextension_use_legacy[] =
13829   {"Not Allowed", "Allowed"};
13830
13831 #define LOOKUP(id, name) \
13832   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13833 static arm_attr_public_tag arm_attr_public_tags[] =
13834 {
13835   {4, "CPU_raw_name", 1, NULL},
13836   {5, "CPU_name", 1, NULL},
13837   LOOKUP(6, CPU_arch),
13838   {7, "CPU_arch_profile", 0, NULL},
13839   LOOKUP(8, ARM_ISA_use),
13840   LOOKUP(9, THUMB_ISA_use),
13841   LOOKUP(10, FP_arch),
13842   LOOKUP(11, WMMX_arch),
13843   LOOKUP(12, Advanced_SIMD_arch),
13844   LOOKUP(13, PCS_config),
13845   LOOKUP(14, ABI_PCS_R9_use),
13846   LOOKUP(15, ABI_PCS_RW_data),
13847   LOOKUP(16, ABI_PCS_RO_data),
13848   LOOKUP(17, ABI_PCS_GOT_use),
13849   LOOKUP(18, ABI_PCS_wchar_t),
13850   LOOKUP(19, ABI_FP_rounding),
13851   LOOKUP(20, ABI_FP_denormal),
13852   LOOKUP(21, ABI_FP_exceptions),
13853   LOOKUP(22, ABI_FP_user_exceptions),
13854   LOOKUP(23, ABI_FP_number_model),
13855   {24, "ABI_align_needed", 0, NULL},
13856   {25, "ABI_align_preserved", 0, NULL},
13857   LOOKUP(26, ABI_enum_size),
13858   LOOKUP(27, ABI_HardFP_use),
13859   LOOKUP(28, ABI_VFP_args),
13860   LOOKUP(29, ABI_WMMX_args),
13861   LOOKUP(30, ABI_optimization_goals),
13862   LOOKUP(31, ABI_FP_optimization_goals),
13863   {32, "compatibility", 0, NULL},
13864   LOOKUP(34, CPU_unaligned_access),
13865   LOOKUP(36, FP_HP_extension),
13866   LOOKUP(38, ABI_FP_16bit_format),
13867   LOOKUP(42, MPextension_use),
13868   LOOKUP(44, DIV_use),
13869   LOOKUP(46, DSP_extension),
13870   {64, "nodefaults", 0, NULL},
13871   {65, "also_compatible_with", 0, NULL},
13872   LOOKUP(66, T2EE_use),
13873   {67, "conformance", 1, NULL},
13874   LOOKUP(68, Virtualization_use),
13875   LOOKUP(70, MPextension_use_legacy)
13876 };
13877 #undef LOOKUP
13878
13879 static unsigned char *
13880 display_arm_attribute (unsigned char * p,
13881                        const unsigned char * const end)
13882 {
13883   unsigned int tag;
13884   unsigned int len;
13885   unsigned int val;
13886   arm_attr_public_tag * attr;
13887   unsigned i;
13888   unsigned int type;
13889
13890   tag = read_uleb128 (p, &len, end);
13891   p += len;
13892   attr = NULL;
13893   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13894     {
13895       if (arm_attr_public_tags[i].tag == tag)
13896         {
13897           attr = &arm_attr_public_tags[i];
13898           break;
13899         }
13900     }
13901
13902   if (attr)
13903     {
13904       printf ("  Tag_%s: ", attr->name);
13905       switch (attr->type)
13906         {
13907         case 0:
13908           switch (tag)
13909             {
13910             case 7: /* Tag_CPU_arch_profile.  */
13911               val = read_uleb128 (p, &len, end);
13912               p += len;
13913               switch (val)
13914                 {
13915                 case 0: printf (_("None\n")); break;
13916                 case 'A': printf (_("Application\n")); break;
13917                 case 'R': printf (_("Realtime\n")); break;
13918                 case 'M': printf (_("Microcontroller\n")); break;
13919                 case 'S': printf (_("Application or Realtime\n")); break;
13920                 default: printf ("??? (%d)\n", val); break;
13921                 }
13922               break;
13923
13924             case 24: /* Tag_align_needed.  */
13925               val = read_uleb128 (p, &len, end);
13926               p += len;
13927               switch (val)
13928                 {
13929                 case 0: printf (_("None\n")); break;
13930                 case 1: printf (_("8-byte\n")); break;
13931                 case 2: printf (_("4-byte\n")); break;
13932                 case 3: printf ("??? 3\n"); break;
13933                 default:
13934                   if (val <= 12)
13935                     printf (_("8-byte and up to %d-byte extended\n"),
13936                             1 << val);
13937                   else
13938                     printf ("??? (%d)\n", val);
13939                   break;
13940                 }
13941               break;
13942
13943             case 25: /* Tag_align_preserved.  */
13944               val = read_uleb128 (p, &len, end);
13945               p += len;
13946               switch (val)
13947                 {
13948                 case 0: printf (_("None\n")); break;
13949                 case 1: printf (_("8-byte, except leaf SP\n")); break;
13950                 case 2: printf (_("8-byte\n")); break;
13951                 case 3: printf ("??? 3\n"); break;
13952                 default:
13953                   if (val <= 12)
13954                     printf (_("8-byte and up to %d-byte extended\n"),
13955                             1 << val);
13956                   else
13957                     printf ("??? (%d)\n", val);
13958                   break;
13959                 }
13960               break;
13961
13962             case 32: /* Tag_compatibility.  */
13963               {
13964                 val = read_uleb128 (p, &len, end);
13965                 p += len;
13966                 printf (_("flag = %d, vendor = "), val);
13967                 if (p < end - 1)
13968                   {
13969                     size_t maxlen = (end - p) - 1;
13970
13971                     print_symbol ((int) maxlen, (const char *) p);
13972                     p += strnlen ((char *) p, maxlen) + 1;
13973                   }
13974                 else
13975                   {
13976                     printf (_("<corrupt>"));
13977                     p = (unsigned char *) end;
13978                   }
13979                 putchar ('\n');
13980               }
13981               break;
13982
13983             case 64: /* Tag_nodefaults.  */
13984               /* PR 17531: file: 001-505008-0.01.  */
13985               if (p < end)
13986                 p++;
13987               printf (_("True\n"));
13988               break;
13989
13990             case 65: /* Tag_also_compatible_with.  */
13991               val = read_uleb128 (p, &len, end);
13992               p += len;
13993               if (val == 6 /* Tag_CPU_arch.  */)
13994                 {
13995                   val = read_uleb128 (p, &len, end);
13996                   p += len;
13997                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13998                     printf ("??? (%d)\n", val);
13999                   else
14000                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14001                 }
14002               else
14003                 printf ("???\n");
14004               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14005                 ;
14006               break;
14007
14008             default:
14009               printf (_("<unknown: %d>\n"), tag);
14010               break;
14011             }
14012           return p;
14013
14014         case 1:
14015           return display_tag_value (-1, p, end);
14016         case 2:
14017           return display_tag_value (0, p, end);
14018
14019         default:
14020           assert (attr->type & 0x80);
14021           val = read_uleb128 (p, &len, end);
14022           p += len;
14023           type = attr->type & 0x7f;
14024           if (val >= type)
14025             printf ("??? (%d)\n", val);
14026           else
14027             printf ("%s\n", attr->table[val]);
14028           return p;
14029         }
14030     }
14031
14032   return display_tag_value (tag, p, end);
14033 }
14034
14035 static unsigned char *
14036 display_gnu_attribute (unsigned char * p,
14037                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14038                        const unsigned char * const end)
14039 {
14040   int tag;
14041   unsigned int len;
14042   unsigned int val;
14043
14044   tag = read_uleb128 (p, &len, end);
14045   p += len;
14046
14047   /* Tag_compatibility is the only generic GNU attribute defined at
14048      present.  */
14049   if (tag == 32)
14050     {
14051       val = read_uleb128 (p, &len, end);
14052       p += len;
14053
14054       printf (_("flag = %d, vendor = "), val);
14055       if (p == end)
14056         {
14057           printf (_("<corrupt>\n"));
14058           warn (_("corrupt vendor attribute\n"));
14059         }
14060       else
14061         {
14062           if (p < end - 1)
14063             {
14064               size_t maxlen = (end - p) - 1;
14065
14066               print_symbol ((int) maxlen, (const char *) p);
14067               p += strnlen ((char *) p, maxlen) + 1;
14068             }
14069           else
14070             {
14071               printf (_("<corrupt>"));
14072               p = (unsigned char *) end;
14073             }
14074           putchar ('\n');
14075         }
14076       return p;
14077     }
14078
14079   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14080     return display_proc_gnu_attribute (p, tag, end);
14081
14082   return display_tag_value (tag, p, end);
14083 }
14084
14085 static unsigned char *
14086 display_power_gnu_attribute (unsigned char * p,
14087                              unsigned int tag,
14088                              const unsigned char * const end)
14089 {
14090   unsigned int len;
14091   unsigned int val;
14092
14093   if (tag == Tag_GNU_Power_ABI_FP)
14094     {
14095       val = read_uleb128 (p, &len, end);
14096       p += len;
14097       printf ("  Tag_GNU_Power_ABI_FP: ");
14098       if (len == 0)
14099         {
14100           printf (_("<corrupt>\n"));
14101           return p;
14102         }
14103
14104       if (val > 15)
14105         printf ("(%#x), ", val);
14106
14107       switch (val & 3)
14108         {
14109         case 0:
14110           printf (_("unspecified hard/soft float, "));
14111           break;
14112         case 1:
14113           printf (_("hard float, "));
14114           break;
14115         case 2:
14116           printf (_("soft float, "));
14117           break;
14118         case 3:
14119           printf (_("single-precision hard float, "));
14120           break;
14121         }
14122
14123       switch (val & 0xC)
14124         {
14125         case 0:
14126           printf (_("unspecified long double\n"));
14127           break;
14128         case 4:
14129           printf (_("128-bit IBM long double\n"));
14130           break;
14131         case 8:
14132           printf (_("64-bit long double\n"));
14133           break;
14134         case 12:
14135           printf (_("128-bit IEEE long double\n"));
14136           break;
14137         }
14138       return p;
14139     }
14140
14141   if (tag == Tag_GNU_Power_ABI_Vector)
14142     {
14143       val = read_uleb128 (p, &len, end);
14144       p += len;
14145       printf ("  Tag_GNU_Power_ABI_Vector: ");
14146       if (len == 0)
14147         {
14148           printf (_("<corrupt>\n"));
14149           return p;
14150         }
14151
14152       if (val > 3)
14153         printf ("(%#x), ", val);
14154
14155       switch (val & 3)
14156         {
14157         case 0:
14158           printf (_("unspecified\n"));
14159           break;
14160         case 1:
14161           printf (_("generic\n"));
14162           break;
14163         case 2:
14164           printf ("AltiVec\n");
14165           break;
14166         case 3:
14167           printf ("SPE\n");
14168           break;
14169         }
14170       return p;
14171     }
14172
14173   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14174     {
14175       val = read_uleb128 (p, &len, end);
14176       p += len;
14177       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14178       if (len == 0)
14179         {
14180           printf (_("<corrupt>\n"));
14181           return p;
14182         }
14183
14184       if (val > 2)
14185         printf ("(%#x), ", val);
14186
14187       switch (val & 3)
14188         {
14189         case 0:
14190           printf (_("unspecified\n"));
14191           break;
14192         case 1:
14193           printf ("r3/r4\n");
14194           break;
14195         case 2:
14196           printf (_("memory\n"));
14197           break;
14198         case 3:
14199           printf ("???\n");
14200           break;
14201         }
14202       return p;
14203     }
14204
14205   return display_tag_value (tag & 1, p, end);
14206 }
14207
14208 static unsigned char *
14209 display_s390_gnu_attribute (unsigned char * p,
14210                             unsigned int tag,
14211                             const unsigned char * const end)
14212 {
14213   unsigned int len;
14214   int val;
14215
14216   if (tag == Tag_GNU_S390_ABI_Vector)
14217     {
14218       val = read_uleb128 (p, &len, end);
14219       p += len;
14220       printf ("  Tag_GNU_S390_ABI_Vector: ");
14221
14222       switch (val)
14223         {
14224         case 0:
14225           printf (_("any\n"));
14226           break;
14227         case 1:
14228           printf (_("software\n"));
14229           break;
14230         case 2:
14231           printf (_("hardware\n"));
14232           break;
14233         default:
14234           printf ("??? (%d)\n", val);
14235           break;
14236         }
14237       return p;
14238    }
14239
14240   return display_tag_value (tag & 1, p, end);
14241 }
14242
14243 static void
14244 display_sparc_hwcaps (unsigned int mask)
14245 {
14246   if (mask)
14247     {
14248       bfd_boolean first = TRUE;
14249
14250       if (mask & ELF_SPARC_HWCAP_MUL32)
14251         fputs ("mul32", stdout), first = FALSE;
14252       if (mask & ELF_SPARC_HWCAP_DIV32)
14253         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14254       if (mask & ELF_SPARC_HWCAP_FSMULD)
14255         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14256       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14257         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14258       if (mask & ELF_SPARC_HWCAP_POPC)
14259         printf ("%spopc", first ? "" : "|"), first = FALSE;
14260       if (mask & ELF_SPARC_HWCAP_VIS)
14261         printf ("%svis", first ? "" : "|"), first = FALSE;
14262       if (mask & ELF_SPARC_HWCAP_VIS2)
14263         printf ("%svis2", first ? "" : "|"), first = FALSE;
14264       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14265         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14266       if (mask & ELF_SPARC_HWCAP_FMAF)
14267         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14268       if (mask & ELF_SPARC_HWCAP_VIS3)
14269         printf ("%svis3", first ? "" : "|"), first = FALSE;
14270       if (mask & ELF_SPARC_HWCAP_HPC)
14271         printf ("%shpc", first ? "" : "|"), first = FALSE;
14272       if (mask & ELF_SPARC_HWCAP_RANDOM)
14273         printf ("%srandom", first ? "" : "|"), first = FALSE;
14274       if (mask & ELF_SPARC_HWCAP_TRANS)
14275         printf ("%strans", first ? "" : "|"), first = FALSE;
14276       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14277         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14278       if (mask & ELF_SPARC_HWCAP_IMA)
14279         printf ("%sima", first ? "" : "|"), first = FALSE;
14280       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14281         printf ("%scspare", first ? "" : "|"), first = FALSE;
14282     }
14283   else
14284     fputc ('0', stdout);
14285   fputc ('\n', stdout);
14286 }
14287
14288 static void
14289 display_sparc_hwcaps2 (unsigned int mask)
14290 {
14291   if (mask)
14292     {
14293       bfd_boolean first = TRUE;
14294
14295       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14296         fputs ("fjathplus", stdout), first = FALSE;
14297       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14298         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14299       if (mask & ELF_SPARC_HWCAP2_ADP)
14300         printf ("%sadp", first ? "" : "|"), first = FALSE;
14301       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14302         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14303       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14304         printf ("%smwait", first ? "" : "|"), first = FALSE;
14305       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14306         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14307       if (mask & ELF_SPARC_HWCAP2_XMONT)
14308         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14309       if (mask & ELF_SPARC_HWCAP2_NSEC)
14310         printf ("%snsec", first ? "" : "|"), first = FALSE;
14311       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14312         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14313       if (mask & ELF_SPARC_HWCAP2_FJDES)
14314         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14315       if (mask & ELF_SPARC_HWCAP2_FJAES)
14316         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14317     }
14318   else
14319     fputc ('0', stdout);
14320   fputc ('\n', stdout);
14321 }
14322
14323 static unsigned char *
14324 display_sparc_gnu_attribute (unsigned char * p,
14325                              unsigned int tag,
14326                              const unsigned char * const end)
14327 {
14328   unsigned int len;
14329   int val;
14330
14331   if (tag == Tag_GNU_Sparc_HWCAPS)
14332     {
14333       val = read_uleb128 (p, &len, end);
14334       p += len;
14335       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14336       display_sparc_hwcaps (val);
14337       return p;
14338     }
14339   if (tag == Tag_GNU_Sparc_HWCAPS2)
14340     {
14341       val = read_uleb128 (p, &len, end);
14342       p += len;
14343       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14344       display_sparc_hwcaps2 (val);
14345       return p;
14346     }
14347
14348   return display_tag_value (tag, p, end);
14349 }
14350
14351 static void
14352 print_mips_fp_abi_value (unsigned int val)
14353 {
14354   switch (val)
14355     {
14356     case Val_GNU_MIPS_ABI_FP_ANY:
14357       printf (_("Hard or soft float\n"));
14358       break;
14359     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14360       printf (_("Hard float (double precision)\n"));
14361       break;
14362     case Val_GNU_MIPS_ABI_FP_SINGLE:
14363       printf (_("Hard float (single precision)\n"));
14364       break;
14365     case Val_GNU_MIPS_ABI_FP_SOFT:
14366       printf (_("Soft float\n"));
14367       break;
14368     case Val_GNU_MIPS_ABI_FP_OLD_64:
14369       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14370       break;
14371     case Val_GNU_MIPS_ABI_FP_XX:
14372       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14373       break;
14374     case Val_GNU_MIPS_ABI_FP_64:
14375       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14376       break;
14377     case Val_GNU_MIPS_ABI_FP_64A:
14378       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14379       break;
14380     case Val_GNU_MIPS_ABI_FP_NAN2008:
14381       printf (_("NaN 2008 compatibility\n"));
14382       break;
14383     default:
14384       printf ("??? (%d)\n", val);
14385       break;
14386     }
14387 }
14388
14389 static unsigned char *
14390 display_mips_gnu_attribute (unsigned char * p,
14391                             unsigned int tag,
14392                             const unsigned char * const end)
14393 {
14394   if (tag == Tag_GNU_MIPS_ABI_FP)
14395     {
14396       unsigned int len;
14397       unsigned int val;
14398
14399       val = read_uleb128 (p, &len, end);
14400       p += len;
14401       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14402
14403       print_mips_fp_abi_value (val);
14404
14405       return p;
14406    }
14407
14408   if (tag == Tag_GNU_MIPS_ABI_MSA)
14409     {
14410       unsigned int len;
14411       unsigned int val;
14412
14413       val = read_uleb128 (p, &len, end);
14414       p += len;
14415       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14416
14417       switch (val)
14418         {
14419         case Val_GNU_MIPS_ABI_MSA_ANY:
14420           printf (_("Any MSA or not\n"));
14421           break;
14422         case Val_GNU_MIPS_ABI_MSA_128:
14423           printf (_("128-bit MSA\n"));
14424           break;
14425         default:
14426           printf ("??? (%d)\n", val);
14427           break;
14428         }
14429       return p;
14430     }
14431
14432   return display_tag_value (tag & 1, p, end);
14433 }
14434
14435 static unsigned char *
14436 display_tic6x_attribute (unsigned char * p,
14437                          const unsigned char * const end)
14438 {
14439   unsigned int tag;
14440   unsigned int len;
14441   int val;
14442
14443   tag = read_uleb128 (p, &len, end);
14444   p += len;
14445
14446   switch (tag)
14447     {
14448     case Tag_ISA:
14449       val = read_uleb128 (p, &len, end);
14450       p += len;
14451       printf ("  Tag_ISA: ");
14452
14453       switch (val)
14454         {
14455         case C6XABI_Tag_ISA_none:
14456           printf (_("None\n"));
14457           break;
14458         case C6XABI_Tag_ISA_C62X:
14459           printf ("C62x\n");
14460           break;
14461         case C6XABI_Tag_ISA_C67X:
14462           printf ("C67x\n");
14463           break;
14464         case C6XABI_Tag_ISA_C67XP:
14465           printf ("C67x+\n");
14466           break;
14467         case C6XABI_Tag_ISA_C64X:
14468           printf ("C64x\n");
14469           break;
14470         case C6XABI_Tag_ISA_C64XP:
14471           printf ("C64x+\n");
14472           break;
14473         case C6XABI_Tag_ISA_C674X:
14474           printf ("C674x\n");
14475           break;
14476         default:
14477           printf ("??? (%d)\n", val);
14478           break;
14479         }
14480       return p;
14481
14482     case Tag_ABI_wchar_t:
14483       val = read_uleb128 (p, &len, end);
14484       p += len;
14485       printf ("  Tag_ABI_wchar_t: ");
14486       switch (val)
14487         {
14488         case 0:
14489           printf (_("Not used\n"));
14490           break;
14491         case 1:
14492           printf (_("2 bytes\n"));
14493           break;
14494         case 2:
14495           printf (_("4 bytes\n"));
14496           break;
14497         default:
14498           printf ("??? (%d)\n", val);
14499           break;
14500         }
14501       return p;
14502
14503     case Tag_ABI_stack_align_needed:
14504       val = read_uleb128 (p, &len, end);
14505       p += len;
14506       printf ("  Tag_ABI_stack_align_needed: ");
14507       switch (val)
14508         {
14509         case 0:
14510           printf (_("8-byte\n"));
14511           break;
14512         case 1:
14513           printf (_("16-byte\n"));
14514           break;
14515         default:
14516           printf ("??? (%d)\n", val);
14517           break;
14518         }
14519       return p;
14520
14521     case Tag_ABI_stack_align_preserved:
14522       val = read_uleb128 (p, &len, end);
14523       p += len;
14524       printf ("  Tag_ABI_stack_align_preserved: ");
14525       switch (val)
14526         {
14527         case 0:
14528           printf (_("8-byte\n"));
14529           break;
14530         case 1:
14531           printf (_("16-byte\n"));
14532           break;
14533         default:
14534           printf ("??? (%d)\n", val);
14535           break;
14536         }
14537       return p;
14538
14539     case Tag_ABI_DSBT:
14540       val = read_uleb128 (p, &len, end);
14541       p += len;
14542       printf ("  Tag_ABI_DSBT: ");
14543       switch (val)
14544         {
14545         case 0:
14546           printf (_("DSBT addressing not used\n"));
14547           break;
14548         case 1:
14549           printf (_("DSBT addressing used\n"));
14550           break;
14551         default:
14552           printf ("??? (%d)\n", val);
14553           break;
14554         }
14555       return p;
14556
14557     case Tag_ABI_PID:
14558       val = read_uleb128 (p, &len, end);
14559       p += len;
14560       printf ("  Tag_ABI_PID: ");
14561       switch (val)
14562         {
14563         case 0:
14564           printf (_("Data addressing position-dependent\n"));
14565           break;
14566         case 1:
14567           printf (_("Data addressing position-independent, GOT near DP\n"));
14568           break;
14569         case 2:
14570           printf (_("Data addressing position-independent, GOT far from DP\n"));
14571           break;
14572         default:
14573           printf ("??? (%d)\n", val);
14574           break;
14575         }
14576       return p;
14577
14578     case Tag_ABI_PIC:
14579       val = read_uleb128 (p, &len, end);
14580       p += len;
14581       printf ("  Tag_ABI_PIC: ");
14582       switch (val)
14583         {
14584         case 0:
14585           printf (_("Code addressing position-dependent\n"));
14586           break;
14587         case 1:
14588           printf (_("Code addressing position-independent\n"));
14589           break;
14590         default:
14591           printf ("??? (%d)\n", val);
14592           break;
14593         }
14594       return p;
14595
14596     case Tag_ABI_array_object_alignment:
14597       val = read_uleb128 (p, &len, end);
14598       p += len;
14599       printf ("  Tag_ABI_array_object_alignment: ");
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_array_object_align_expected:
14618       val = read_uleb128 (p, &len, end);
14619       p += len;
14620       printf ("  Tag_ABI_array_object_align_expected: ");
14621       switch (val)
14622         {
14623         case 0:
14624           printf (_("8-byte\n"));
14625           break;
14626         case 1:
14627           printf (_("4-byte\n"));
14628           break;
14629         case 2:
14630           printf (_("16-byte\n"));
14631           break;
14632         default:
14633           printf ("??? (%d)\n", val);
14634           break;
14635         }
14636       return p;
14637
14638     case Tag_ABI_compatibility:
14639       {
14640         val = read_uleb128 (p, &len, end);
14641         p += len;
14642         printf ("  Tag_ABI_compatibility: ");
14643         printf (_("flag = %d, vendor = "), val);
14644         if (p < end - 1)
14645           {
14646             size_t maxlen = (end - p) - 1;
14647
14648             print_symbol ((int) maxlen, (const char *) p);
14649             p += strnlen ((char *) p, maxlen) + 1;
14650           }
14651         else
14652           {
14653             printf (_("<corrupt>"));
14654             p = (unsigned char *) end;
14655           }
14656         putchar ('\n');
14657         return p;
14658       }
14659
14660     case Tag_ABI_conformance:
14661       {
14662         printf ("  Tag_ABI_conformance: \"");
14663         if (p < end - 1)
14664           {
14665             size_t maxlen = (end - p) - 1;
14666
14667             print_symbol ((int) maxlen, (const char *) p);
14668             p += strnlen ((char *) p, maxlen) + 1;
14669           }
14670         else
14671           {
14672             printf (_("<corrupt>"));
14673             p = (unsigned char *) end;
14674           }
14675         printf ("\"\n");
14676         return p;
14677       }
14678     }
14679
14680   return display_tag_value (tag, p, end);
14681 }
14682
14683 static void
14684 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14685 {
14686   unsigned long addr = 0;
14687   size_t bytes = end - p;
14688
14689   assert (end > p);
14690   while (bytes)
14691     {
14692       int j;
14693       int k;
14694       int lbytes = (bytes > 16 ? 16 : bytes);
14695
14696       printf ("  0x%8.8lx ", addr);
14697
14698       for (j = 0; j < 16; j++)
14699         {
14700           if (j < lbytes)
14701             printf ("%2.2x", p[j]);
14702           else
14703             printf ("  ");
14704
14705           if ((j & 3) == 3)
14706             printf (" ");
14707         }
14708
14709       for (j = 0; j < lbytes; j++)
14710         {
14711           k = p[j];
14712           if (k >= ' ' && k < 0x7f)
14713             printf ("%c", k);
14714           else
14715             printf (".");
14716         }
14717
14718       putchar ('\n');
14719
14720       p  += lbytes;
14721       bytes -= lbytes;
14722       addr += lbytes;
14723     }
14724
14725   putchar ('\n');
14726 }
14727
14728 static unsigned char *
14729 display_msp430x_attribute (unsigned char * p,
14730                            const unsigned char * const end)
14731 {
14732   unsigned int len;
14733   unsigned int val;
14734   unsigned int tag;
14735
14736   tag = read_uleb128 (p, & len, end);
14737   p += len;
14738
14739   switch (tag)
14740     {
14741     case OFBA_MSPABI_Tag_ISA:
14742       val = read_uleb128 (p, &len, end);
14743       p += len;
14744       printf ("  Tag_ISA: ");
14745       switch (val)
14746         {
14747         case 0: printf (_("None\n")); break;
14748         case 1: printf (_("MSP430\n")); break;
14749         case 2: printf (_("MSP430X\n")); break;
14750         default: printf ("??? (%d)\n", val); break;
14751         }
14752       break;
14753
14754     case OFBA_MSPABI_Tag_Code_Model:
14755       val = read_uleb128 (p, &len, end);
14756       p += len;
14757       printf ("  Tag_Code_Model: ");
14758       switch (val)
14759         {
14760         case 0: printf (_("None\n")); break;
14761         case 1: printf (_("Small\n")); break;
14762         case 2: printf (_("Large\n")); break;
14763         default: printf ("??? (%d)\n", val); break;
14764         }
14765       break;
14766
14767     case OFBA_MSPABI_Tag_Data_Model:
14768       val = read_uleb128 (p, &len, end);
14769       p += len;
14770       printf ("  Tag_Data_Model: ");
14771       switch (val)
14772         {
14773         case 0: printf (_("None\n")); break;
14774         case 1: printf (_("Small\n")); break;
14775         case 2: printf (_("Large\n")); break;
14776         case 3: printf (_("Restricted Large\n")); break;
14777         default: printf ("??? (%d)\n", val); break;
14778         }
14779       break;
14780
14781     default:
14782       printf (_("  <unknown tag %d>: "), tag);
14783
14784       if (tag & 1)
14785         {
14786           putchar ('"');
14787           if (p < end - 1)
14788             {
14789               size_t maxlen = (end - p) - 1;
14790
14791               print_symbol ((int) maxlen, (const char *) p);
14792               p += strnlen ((char *) p, maxlen) + 1;
14793             }
14794           else
14795             {
14796               printf (_("<corrupt>"));
14797               p = (unsigned char *) end;
14798             }
14799           printf ("\"\n");
14800         }
14801       else
14802         {
14803           val = read_uleb128 (p, &len, end);
14804           p += len;
14805           printf ("%d (0x%x)\n", val, val);
14806         }
14807       break;
14808    }
14809
14810   assert (p <= end);
14811   return p;
14812 }
14813
14814 static bfd_boolean
14815 process_attributes (FILE * file,
14816                     const char * public_name,
14817                     unsigned int proc_type,
14818                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14819                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14820 {
14821   Elf_Internal_Shdr * sect;
14822   unsigned i;
14823   bfd_boolean res = TRUE;
14824
14825   /* Find the section header so that we get the size.  */
14826   for (i = 0, sect = section_headers;
14827        i < elf_header.e_shnum;
14828        i++, sect++)
14829     {
14830       unsigned char * contents;
14831       unsigned char * p;
14832
14833       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14834         continue;
14835
14836       contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14837                                              sect->sh_size, _("attributes"));
14838       if (contents == NULL)
14839         {
14840           res = FALSE;
14841           continue;
14842         }
14843
14844       p = contents;
14845       /* The first character is the version of the attributes.
14846          Currently only version 1, (aka 'A') is recognised here.  */
14847       if (*p != 'A')
14848         {
14849           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14850           res = FALSE;
14851         }
14852       else
14853         {
14854           bfd_vma section_len;
14855
14856           section_len = sect->sh_size - 1;
14857           p++;
14858
14859           while (section_len > 0)
14860             {
14861               bfd_vma attr_len;
14862               unsigned int namelen;
14863               bfd_boolean public_section;
14864               bfd_boolean gnu_section;
14865
14866               if (section_len <= 4)
14867                 {
14868                   error (_("Tag section ends prematurely\n"));
14869                   res = FALSE;
14870                   break;
14871                 }
14872               attr_len = byte_get (p, 4);
14873               p += 4;
14874
14875               if (attr_len > section_len)
14876                 {
14877                   error (_("Bad attribute length (%u > %u)\n"),
14878                           (unsigned) attr_len, (unsigned) section_len);
14879                   attr_len = section_len;
14880                   res = FALSE;
14881                 }
14882               /* PR 17531: file: 001-101425-0.004  */
14883               else if (attr_len < 5)
14884                 {
14885                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14886                   res = FALSE;
14887                   break;
14888                 }
14889
14890               section_len -= attr_len;
14891               attr_len -= 4;
14892
14893               namelen = strnlen ((char *) p, attr_len) + 1;
14894               if (namelen == 0 || namelen >= attr_len)
14895                 {
14896                   error (_("Corrupt attribute section name\n"));
14897                   res = FALSE;
14898                   break;
14899                 }
14900
14901               printf (_("Attribute Section: "));
14902               print_symbol (INT_MAX, (const char *) p);
14903               putchar ('\n');
14904
14905               if (public_name && streq ((char *) p, public_name))
14906                 public_section = TRUE;
14907               else
14908                 public_section = FALSE;
14909
14910               if (streq ((char *) p, "gnu"))
14911                 gnu_section = TRUE;
14912               else
14913                 gnu_section = FALSE;
14914
14915               p += namelen;
14916               attr_len -= namelen;
14917
14918               while (attr_len > 0 && p < contents + sect->sh_size)
14919                 {
14920                   int tag;
14921                   int val;
14922                   bfd_vma size;
14923                   unsigned char * end;
14924
14925                   /* PR binutils/17531: Safe handling of corrupt files.  */
14926                   if (attr_len < 6)
14927                     {
14928                       error (_("Unused bytes at end of section\n"));
14929                       res = FALSE;
14930                       section_len = 0;
14931                       break;
14932                     }
14933
14934                   tag = *(p++);
14935                   size = byte_get (p, 4);
14936                   if (size > attr_len)
14937                     {
14938                       error (_("Bad subsection length (%u > %u)\n"),
14939                               (unsigned) size, (unsigned) attr_len);
14940                       res = FALSE;
14941                       size = attr_len;
14942                     }
14943                   /* PR binutils/17531: Safe handling of corrupt files.  */
14944                   if (size < 6)
14945                     {
14946                       error (_("Bad subsection length (%u < 6)\n"),
14947                               (unsigned) size);
14948                       res = FALSE;
14949                       section_len = 0;
14950                       break;
14951                     }
14952
14953                   attr_len -= size;
14954                   end = p + size - 1;
14955                   assert (end <= contents + sect->sh_size);
14956                   p += 4;
14957
14958                   switch (tag)
14959                     {
14960                     case 1:
14961                       printf (_("File Attributes\n"));
14962                       break;
14963                     case 2:
14964                       printf (_("Section Attributes:"));
14965                       goto do_numlist;
14966                     case 3:
14967                       printf (_("Symbol Attributes:"));
14968                       /* Fall through.  */
14969                     do_numlist:
14970                       for (;;)
14971                         {
14972                           unsigned int j;
14973
14974                           val = read_uleb128 (p, &j, end);
14975                           p += j;
14976                           if (val == 0)
14977                             break;
14978                           printf (" %d", val);
14979                         }
14980                       printf ("\n");
14981                       break;
14982                     default:
14983                       printf (_("Unknown tag: %d\n"), tag);
14984                       public_section = FALSE;
14985                       break;
14986                     }
14987
14988                   if (public_section && display_pub_attribute != NULL)
14989                     {
14990                       while (p < end)
14991                         p = display_pub_attribute (p, end);
14992                       assert (p == end);
14993                     }
14994                   else if (gnu_section && display_proc_gnu_attribute != NULL)
14995                     {
14996                       while (p < end)
14997                         p = display_gnu_attribute (p,
14998                                                    display_proc_gnu_attribute,
14999                                                    end);
15000                       assert (p == end);
15001                     }
15002                   else if (p < end)
15003                     {
15004                       printf (_("  Unknown attribute:\n"));
15005                       display_raw_attribute (p, end);
15006                       p = end;
15007                     }
15008                   else
15009                     attr_len = 0;
15010                 }
15011             }
15012         }
15013
15014       free (contents);
15015     }
15016
15017   return res;
15018 }
15019
15020 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15021    Print the Address, Access and Initial fields of an entry at VMA ADDR
15022    and return the VMA of the next entry, or -1 if there was a problem.
15023    Does not read from DATA_END or beyond.  */
15024
15025 static bfd_vma
15026 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15027                       unsigned char * data_end)
15028 {
15029   printf ("  ");
15030   print_vma (addr, LONG_HEX);
15031   printf (" ");
15032   if (addr < pltgot + 0xfff0)
15033     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15034   else
15035     printf ("%10s", "");
15036   printf (" ");
15037   if (data == NULL)
15038     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15039   else
15040     {
15041       bfd_vma entry;
15042       unsigned char * from = data + addr - pltgot;
15043
15044       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15045         {
15046           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15047           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15048           return (bfd_vma) -1;
15049         }
15050       else
15051         {
15052           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15053           print_vma (entry, LONG_HEX);
15054         }
15055     }
15056   return addr + (is_32bit_elf ? 4 : 8);
15057 }
15058
15059 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15060    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15061    ADDR and return the VMA of the next entry.  */
15062
15063 static bfd_vma
15064 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15065 {
15066   printf ("  ");
15067   print_vma (addr, LONG_HEX);
15068   printf (" ");
15069   if (data == NULL)
15070     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15071   else
15072     {
15073       bfd_vma entry;
15074
15075       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15076       print_vma (entry, LONG_HEX);
15077     }
15078   return addr + (is_32bit_elf ? 4 : 8);
15079 }
15080
15081 static void
15082 print_mips_ases (unsigned int mask)
15083 {
15084   if (mask & AFL_ASE_DSP)
15085     fputs ("\n\tDSP ASE", stdout);
15086   if (mask & AFL_ASE_DSPR2)
15087     fputs ("\n\tDSP R2 ASE", stdout);
15088   if (mask & AFL_ASE_DSPR3)
15089     fputs ("\n\tDSP R3 ASE", stdout);
15090   if (mask & AFL_ASE_EVA)
15091     fputs ("\n\tEnhanced VA Scheme", stdout);
15092   if (mask & AFL_ASE_MCU)
15093     fputs ("\n\tMCU (MicroController) ASE", stdout);
15094   if (mask & AFL_ASE_MDMX)
15095     fputs ("\n\tMDMX ASE", stdout);
15096   if (mask & AFL_ASE_MIPS3D)
15097     fputs ("\n\tMIPS-3D ASE", stdout);
15098   if (mask & AFL_ASE_MT)
15099     fputs ("\n\tMT ASE", stdout);
15100   if (mask & AFL_ASE_SMARTMIPS)
15101     fputs ("\n\tSmartMIPS ASE", stdout);
15102   if (mask & AFL_ASE_VIRT)
15103     fputs ("\n\tVZ ASE", stdout);
15104   if (mask & AFL_ASE_MSA)
15105     fputs ("\n\tMSA ASE", stdout);
15106   if (mask & AFL_ASE_MIPS16)
15107     fputs ("\n\tMIPS16 ASE", stdout);
15108   if (mask & AFL_ASE_MICROMIPS)
15109     fputs ("\n\tMICROMIPS ASE", stdout);
15110   if (mask & AFL_ASE_XPA)
15111     fputs ("\n\tXPA ASE", stdout);
15112   if (mask & AFL_ASE_MIPS16E2)
15113     fputs ("\n\tMIPS16e2 ASE", stdout);
15114   if (mask == 0)
15115     fprintf (stdout, "\n\t%s", _("None"));
15116   else if ((mask & ~AFL_ASE_MASK) != 0)
15117     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15118 }
15119
15120 static void
15121 print_mips_isa_ext (unsigned int isa_ext)
15122 {
15123   switch (isa_ext)
15124     {
15125     case 0:
15126       fputs (_("None"), stdout);
15127       break;
15128     case AFL_EXT_XLR:
15129       fputs ("RMI XLR", stdout);
15130       break;
15131     case AFL_EXT_OCTEON3:
15132       fputs ("Cavium Networks Octeon3", stdout);
15133       break;
15134     case AFL_EXT_OCTEON2:
15135       fputs ("Cavium Networks Octeon2", stdout);
15136       break;
15137     case AFL_EXT_OCTEONP:
15138       fputs ("Cavium Networks OcteonP", stdout);
15139       break;
15140     case AFL_EXT_LOONGSON_3A:
15141       fputs ("Loongson 3A", stdout);
15142       break;
15143     case AFL_EXT_OCTEON:
15144       fputs ("Cavium Networks Octeon", stdout);
15145       break;
15146     case AFL_EXT_5900:
15147       fputs ("Toshiba R5900", stdout);
15148       break;
15149     case AFL_EXT_4650:
15150       fputs ("MIPS R4650", stdout);
15151       break;
15152     case AFL_EXT_4010:
15153       fputs ("LSI R4010", stdout);
15154       break;
15155     case AFL_EXT_4100:
15156       fputs ("NEC VR4100", stdout);
15157       break;
15158     case AFL_EXT_3900:
15159       fputs ("Toshiba R3900", stdout);
15160       break;
15161     case AFL_EXT_10000:
15162       fputs ("MIPS R10000", stdout);
15163       break;
15164     case AFL_EXT_SB1:
15165       fputs ("Broadcom SB-1", stdout);
15166       break;
15167     case AFL_EXT_4111:
15168       fputs ("NEC VR4111/VR4181", stdout);
15169       break;
15170     case AFL_EXT_4120:
15171       fputs ("NEC VR4120", stdout);
15172       break;
15173     case AFL_EXT_5400:
15174       fputs ("NEC VR5400", stdout);
15175       break;
15176     case AFL_EXT_5500:
15177       fputs ("NEC VR5500", stdout);
15178       break;
15179     case AFL_EXT_LOONGSON_2E:
15180       fputs ("ST Microelectronics Loongson 2E", stdout);
15181       break;
15182     case AFL_EXT_LOONGSON_2F:
15183       fputs ("ST Microelectronics Loongson 2F", stdout);
15184       break;
15185     case AFL_EXT_INTERAPTIV_MR2:
15186       fputs ("Imagination interAptiv MR2", stdout);
15187       break;
15188     default:
15189       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15190     }
15191 }
15192
15193 static signed int
15194 get_mips_reg_size (int reg_size)
15195 {
15196   return (reg_size == AFL_REG_NONE) ? 0
15197          : (reg_size == AFL_REG_32) ? 32
15198          : (reg_size == AFL_REG_64) ? 64
15199          : (reg_size == AFL_REG_128) ? 128
15200          : -1;
15201 }
15202
15203 static bfd_boolean
15204 process_mips_specific (FILE * file)
15205 {
15206   Elf_Internal_Dyn * entry;
15207   Elf_Internal_Shdr *sect = NULL;
15208   size_t liblist_offset = 0;
15209   size_t liblistno = 0;
15210   size_t conflictsno = 0;
15211   size_t options_offset = 0;
15212   size_t conflicts_offset = 0;
15213   size_t pltrelsz = 0;
15214   size_t pltrel = 0;
15215   bfd_vma pltgot = 0;
15216   bfd_vma mips_pltgot = 0;
15217   bfd_vma jmprel = 0;
15218   bfd_vma local_gotno = 0;
15219   bfd_vma gotsym = 0;
15220   bfd_vma symtabno = 0;
15221   bfd_boolean res = TRUE;
15222
15223   if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15224                             display_mips_gnu_attribute))
15225     res = FALSE;
15226
15227   sect = find_section (".MIPS.abiflags");
15228
15229   if (sect != NULL)
15230     {
15231       Elf_External_ABIFlags_v0 *abiflags_ext;
15232       Elf_Internal_ABIFlags_v0 abiflags_in;
15233
15234       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15235         {
15236           error (_("Corrupt MIPS ABI Flags section.\n"));
15237           res = FALSE;
15238         }
15239       else
15240         {
15241           abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15242                                    sect->sh_size, _("MIPS ABI Flags section"));
15243           if (abiflags_ext)
15244             {
15245               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15246               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15247               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15248               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15249               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15250               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15251               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15252               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15253               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15254               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15255               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15256
15257               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15258               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15259               if (abiflags_in.isa_rev > 1)
15260                 printf ("r%d", abiflags_in.isa_rev);
15261               printf ("\nGPR size: %d",
15262                       get_mips_reg_size (abiflags_in.gpr_size));
15263               printf ("\nCPR1 size: %d",
15264                       get_mips_reg_size (abiflags_in.cpr1_size));
15265               printf ("\nCPR2 size: %d",
15266                       get_mips_reg_size (abiflags_in.cpr2_size));
15267               fputs ("\nFP ABI: ", stdout);
15268               print_mips_fp_abi_value (abiflags_in.fp_abi);
15269               fputs ("ISA Extension: ", stdout);
15270               print_mips_isa_ext (abiflags_in.isa_ext);
15271               fputs ("\nASEs:", stdout);
15272               print_mips_ases (abiflags_in.ases);
15273               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15274               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15275               fputc ('\n', stdout);
15276               free (abiflags_ext);
15277             }
15278         }
15279     }
15280
15281   /* We have a lot of special sections.  Thanks SGI!  */
15282   if (dynamic_section == NULL)
15283     {
15284       /* No dynamic information available.  See if there is static GOT.  */
15285       sect = find_section (".got");
15286       if (sect != NULL)
15287         {
15288           unsigned char *data_end;
15289           unsigned char *data;
15290           bfd_vma ent, end;
15291           int addr_size;
15292
15293           pltgot = sect->sh_addr;
15294
15295           ent = pltgot;
15296           addr_size = (is_32bit_elf ? 4 : 8);
15297           end = pltgot + sect->sh_size;
15298
15299           data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15300                                              end - pltgot, 1,
15301                                              _("Global Offset Table data"));
15302           /* PR 12855: Null data is handled gracefully throughout.  */
15303           data_end = data + (end - pltgot);
15304
15305           printf (_("\nStatic GOT:\n"));
15306           printf (_(" Canonical gp value: "));
15307           print_vma (ent + 0x7ff0, LONG_HEX);
15308           printf ("\n\n");
15309
15310           /* In a dynamic binary GOT[0] is reserved for the dynamic
15311              loader to store the lazy resolver pointer, however in
15312              a static binary it may well have been omitted and GOT
15313              reduced to a table of addresses.
15314              PR 21344: Check for the entry being fully available
15315              before fetching it.  */
15316           if (data
15317               && data + ent - pltgot + addr_size <= data_end
15318               && byte_get (data + ent - pltgot, addr_size) == 0)
15319             {
15320               printf (_(" Reserved entries:\n"));
15321               printf (_("  %*s %10s %*s\n"),
15322                       addr_size * 2, _("Address"), _("Access"),
15323                       addr_size * 2, _("Value"));
15324               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15325               printf ("\n");
15326               if (ent == (bfd_vma) -1)
15327                 goto sgot_print_fail;
15328
15329               /* Check for the MSB of GOT[1] being set, identifying a
15330                  GNU object.  This entry will be used by some runtime
15331                  loaders, to store the module pointer.  Otherwise this
15332                  is an ordinary local entry.
15333                  PR 21344: Check for the entry being fully available
15334                  before fetching it.  */
15335               if (data
15336                   && data + ent - pltgot + addr_size <= data_end
15337                   && (byte_get (data + ent - pltgot, addr_size)
15338                       >> (addr_size * 8 - 1)) != 0)
15339                 {
15340                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15341                   printf ("\n");
15342                   if (ent == (bfd_vma) -1)
15343                     goto sgot_print_fail;
15344                 }
15345               printf ("\n");
15346             }
15347
15348           if (data != NULL && ent < end)
15349             {
15350               printf (_(" Local entries:\n"));
15351               printf ("  %*s %10s %*s\n",
15352                       addr_size * 2, _("Address"), _("Access"),
15353                       addr_size * 2, _("Value"));
15354               while (ent < end)
15355                 {
15356                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15357                   printf ("\n");
15358                   if (ent == (bfd_vma) -1)
15359                     goto sgot_print_fail;
15360                 }
15361               printf ("\n");
15362             }
15363
15364         sgot_print_fail:
15365           if (data)
15366             free (data);
15367         }
15368       return res;
15369     }
15370
15371   for (entry = dynamic_section;
15372        /* PR 17531 file: 012-50589-0.004.  */
15373        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15374        ++entry)
15375     switch (entry->d_tag)
15376       {
15377       case DT_MIPS_LIBLIST:
15378         liblist_offset
15379           = offset_from_vma (file, entry->d_un.d_val,
15380                              liblistno * sizeof (Elf32_External_Lib));
15381         break;
15382       case DT_MIPS_LIBLISTNO:
15383         liblistno = entry->d_un.d_val;
15384         break;
15385       case DT_MIPS_OPTIONS:
15386         options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15387         break;
15388       case DT_MIPS_CONFLICT:
15389         conflicts_offset
15390           = offset_from_vma (file, entry->d_un.d_val,
15391                              conflictsno * sizeof (Elf32_External_Conflict));
15392         break;
15393       case DT_MIPS_CONFLICTNO:
15394         conflictsno = entry->d_un.d_val;
15395         break;
15396       case DT_PLTGOT:
15397         pltgot = entry->d_un.d_ptr;
15398         break;
15399       case DT_MIPS_LOCAL_GOTNO:
15400         local_gotno = entry->d_un.d_val;
15401         break;
15402       case DT_MIPS_GOTSYM:
15403         gotsym = entry->d_un.d_val;
15404         break;
15405       case DT_MIPS_SYMTABNO:
15406         symtabno = entry->d_un.d_val;
15407         break;
15408       case DT_MIPS_PLTGOT:
15409         mips_pltgot = entry->d_un.d_ptr;
15410         break;
15411       case DT_PLTREL:
15412         pltrel = entry->d_un.d_val;
15413         break;
15414       case DT_PLTRELSZ:
15415         pltrelsz = entry->d_un.d_val;
15416         break;
15417       case DT_JMPREL:
15418         jmprel = entry->d_un.d_ptr;
15419         break;
15420       default:
15421         break;
15422       }
15423
15424   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15425     {
15426       Elf32_External_Lib * elib;
15427       size_t cnt;
15428
15429       elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15430                                               liblistno,
15431                                               sizeof (Elf32_External_Lib),
15432                                               _("liblist section data"));
15433       if (elib)
15434         {
15435           printf (_("\nSection '.liblist' contains %lu entries:\n"),
15436                   (unsigned long) liblistno);
15437           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15438                  stdout);
15439
15440           for (cnt = 0; cnt < liblistno; ++cnt)
15441             {
15442               Elf32_Lib liblist;
15443               time_t atime;
15444               char timebuf[128];
15445               struct tm * tmp;
15446
15447               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15448               atime = BYTE_GET (elib[cnt].l_time_stamp);
15449               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15450               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15451               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15452
15453               tmp = gmtime (&atime);
15454               snprintf (timebuf, sizeof (timebuf),
15455                         "%04u-%02u-%02uT%02u:%02u:%02u",
15456                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15457                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15458
15459               printf ("%3lu: ", (unsigned long) cnt);
15460               if (VALID_DYNAMIC_NAME (liblist.l_name))
15461                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15462               else
15463                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15464               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15465                       liblist.l_version);
15466
15467               if (liblist.l_flags == 0)
15468                 puts (_(" NONE"));
15469               else
15470                 {
15471                   static const struct
15472                   {
15473                     const char * name;
15474                     int bit;
15475                   }
15476                   l_flags_vals[] =
15477                   {
15478                     { " EXACT_MATCH", LL_EXACT_MATCH },
15479                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15480                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15481                     { " EXPORTS", LL_EXPORTS },
15482                     { " DELAY_LOAD", LL_DELAY_LOAD },
15483                     { " DELTA", LL_DELTA }
15484                   };
15485                   int flags = liblist.l_flags;
15486                   size_t fcnt;
15487
15488                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15489                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15490                       {
15491                         fputs (l_flags_vals[fcnt].name, stdout);
15492                         flags ^= l_flags_vals[fcnt].bit;
15493                       }
15494                   if (flags != 0)
15495                     printf (" %#x", (unsigned int) flags);
15496
15497                   puts ("");
15498                 }
15499             }
15500
15501           free (elib);
15502         }
15503       else
15504         res = FALSE;
15505     }
15506
15507   if (options_offset != 0)
15508     {
15509       Elf_External_Options * eopt;
15510       Elf_Internal_Options * iopt;
15511       Elf_Internal_Options * option;
15512       size_t offset;
15513       int cnt;
15514       sect = section_headers;
15515
15516       /* Find the section header so that we get the size.  */
15517       sect = find_section_by_type (SHT_MIPS_OPTIONS);
15518       /* PR 17533 file: 012-277276-0.004.  */
15519       if (sect == NULL)
15520         {
15521           error (_("No MIPS_OPTIONS header found\n"));
15522           return FALSE;
15523         }
15524
15525       eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15526                                                 sect->sh_size, _("options"));
15527       if (eopt)
15528         {
15529           iopt = (Elf_Internal_Options *)
15530               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15531           if (iopt == NULL)
15532             {
15533               error (_("Out of memory allocating space for MIPS options\n"));
15534               return FALSE;
15535             }
15536
15537           offset = cnt = 0;
15538           option = iopt;
15539
15540           while (offset <= sect->sh_size - sizeof (* eopt))
15541             {
15542               Elf_External_Options * eoption;
15543
15544               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15545
15546               option->kind = BYTE_GET (eoption->kind);
15547               option->size = BYTE_GET (eoption->size);
15548               option->section = BYTE_GET (eoption->section);
15549               option->info = BYTE_GET (eoption->info);
15550
15551               /* PR 17531: file: ffa0fa3b.  */
15552               if (option->size < sizeof (* eopt)
15553                   || offset + option->size > sect->sh_size)
15554                 {
15555                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15556                   return FALSE;
15557                 }
15558               offset += option->size;
15559
15560               ++option;
15561               ++cnt;
15562             }
15563
15564           printf (_("\nSection '%s' contains %d entries:\n"),
15565                   printable_section_name (sect), cnt);
15566
15567           option = iopt;
15568           offset = 0;
15569
15570           while (cnt-- > 0)
15571             {
15572               size_t len;
15573
15574               switch (option->kind)
15575                 {
15576                 case ODK_NULL:
15577                   /* This shouldn't happen.  */
15578                   printf (" NULL       %d %lx", option->section, option->info);
15579                   break;
15580                 case ODK_REGINFO:
15581                   printf (" REGINFO    ");
15582                   if (elf_header.e_machine == EM_MIPS)
15583                     {
15584                       /* 32bit form.  */
15585                       Elf32_External_RegInfo * ereg;
15586                       Elf32_RegInfo reginfo;
15587
15588                       ereg = (Elf32_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%lx\n",
15597                               reginfo.ri_gprmask,
15598                               (unsigned long) reginfo.ri_gp_value);
15599                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15600                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15601                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15602                     }
15603                   else
15604                     {
15605                       /* 64 bit form.  */
15606                       Elf64_External_RegInfo * ereg;
15607                       Elf64_Internal_RegInfo reginfo;
15608
15609                       ereg = (Elf64_External_RegInfo *) (option + 1);
15610                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15611                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15612                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15613                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15614                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15615                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15616
15617                       printf ("GPR %08lx  GP 0x",
15618                               reginfo.ri_gprmask);
15619                       printf_vma (reginfo.ri_gp_value);
15620                       printf ("\n");
15621
15622                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15623                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15624                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15625                     }
15626                   ++option;
15627                   continue;
15628                 case ODK_EXCEPTIONS:
15629                   fputs (" EXCEPTIONS fpe_min(", stdout);
15630                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15631                   fputs (") fpe_max(", stdout);
15632                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15633                   fputs (")", stdout);
15634
15635                   if (option->info & OEX_PAGE0)
15636                     fputs (" PAGE0", stdout);
15637                   if (option->info & OEX_SMM)
15638                     fputs (" SMM", stdout);
15639                   if (option->info & OEX_FPDBUG)
15640                     fputs (" FPDBUG", stdout);
15641                   if (option->info & OEX_DISMISS)
15642                     fputs (" DISMISS", stdout);
15643                   break;
15644                 case ODK_PAD:
15645                   fputs (" PAD       ", stdout);
15646                   if (option->info & OPAD_PREFIX)
15647                     fputs (" PREFIX", stdout);
15648                   if (option->info & OPAD_POSTFIX)
15649                     fputs (" POSTFIX", stdout);
15650                   if (option->info & OPAD_SYMBOL)
15651                     fputs (" SYMBOL", stdout);
15652                   break;
15653                 case ODK_HWPATCH:
15654                   fputs (" HWPATCH   ", stdout);
15655                   if (option->info & OHW_R4KEOP)
15656                     fputs (" R4KEOP", stdout);
15657                   if (option->info & OHW_R8KPFETCH)
15658                     fputs (" R8KPFETCH", stdout);
15659                   if (option->info & OHW_R5KEOP)
15660                     fputs (" R5KEOP", stdout);
15661                   if (option->info & OHW_R5KCVTL)
15662                     fputs (" R5KCVTL", stdout);
15663                   break;
15664                 case ODK_FILL:
15665                   fputs (" FILL       ", stdout);
15666                   /* XXX Print content of info word?  */
15667                   break;
15668                 case ODK_TAGS:
15669                   fputs (" TAGS       ", stdout);
15670                   /* XXX Print content of info word?  */
15671                   break;
15672                 case ODK_HWAND:
15673                   fputs (" HWAND     ", stdout);
15674                   if (option->info & OHWA0_R4KEOP_CHECKED)
15675                     fputs (" R4KEOP_CHECKED", stdout);
15676                   if (option->info & OHWA0_R4KEOP_CLEAN)
15677                     fputs (" R4KEOP_CLEAN", stdout);
15678                   break;
15679                 case ODK_HWOR:
15680                   fputs (" HWOR      ", stdout);
15681                   if (option->info & OHWA0_R4KEOP_CHECKED)
15682                     fputs (" R4KEOP_CHECKED", stdout);
15683                   if (option->info & OHWA0_R4KEOP_CLEAN)
15684                     fputs (" R4KEOP_CLEAN", stdout);
15685                   break;
15686                 case ODK_GP_GROUP:
15687                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
15688                           option->info & OGP_GROUP,
15689                           (option->info & OGP_SELF) >> 16);
15690                   break;
15691                 case ODK_IDENT:
15692                   printf (" IDENT     %#06lx  self-contained %#06lx",
15693                           option->info & OGP_GROUP,
15694                           (option->info & OGP_SELF) >> 16);
15695                   break;
15696                 default:
15697                   /* This shouldn't happen.  */
15698                   printf (" %3d ???     %d %lx",
15699                           option->kind, option->section, option->info);
15700                   break;
15701                 }
15702
15703               len = sizeof (* eopt);
15704               while (len < option->size)
15705                 {
15706                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
15707
15708                   if (ISPRINT (datum))
15709                     printf ("%c", datum);
15710                   else
15711                     printf ("\\%03o", datum);
15712                   len ++;
15713                 }
15714               fputs ("\n", stdout);
15715
15716               offset += option->size;
15717               ++option;
15718             }
15719
15720           free (eopt);
15721         }
15722       else
15723         res = FALSE;
15724     }
15725
15726   if (conflicts_offset != 0 && conflictsno != 0)
15727     {
15728       Elf32_Conflict * iconf;
15729       size_t cnt;
15730
15731       if (dynamic_symbols == NULL)
15732         {
15733           error (_("conflict list found without a dynamic symbol table\n"));
15734           return FALSE;
15735         }
15736
15737       /* PR 21345 - print a slightly more helpful error message
15738          if we are sure that the cmalloc will fail.  */
15739       if (conflictsno * sizeof (* iconf) > current_file_size)
15740         {
15741           error (_("Overlarge number of conflicts detected: %lx\n"),
15742                  (long) conflictsno);
15743           return FALSE;
15744         }
15745
15746       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15747       if (iconf == NULL)
15748         {
15749           error (_("Out of memory allocating space for dynamic conflicts\n"));
15750           return FALSE;
15751         }
15752
15753       if (is_32bit_elf)
15754         {
15755           Elf32_External_Conflict * econf32;
15756
15757           econf32 = (Elf32_External_Conflict *)
15758               get_data (NULL, file, conflicts_offset, conflictsno,
15759                         sizeof (* econf32), _("conflict"));
15760           if (!econf32)
15761             return FALSE;
15762
15763           for (cnt = 0; cnt < conflictsno; ++cnt)
15764             iconf[cnt] = BYTE_GET (econf32[cnt]);
15765
15766           free (econf32);
15767         }
15768       else
15769         {
15770           Elf64_External_Conflict * econf64;
15771
15772           econf64 = (Elf64_External_Conflict *)
15773               get_data (NULL, file, conflicts_offset, conflictsno,
15774                         sizeof (* econf64), _("conflict"));
15775           if (!econf64)
15776             return FALSE;
15777
15778           for (cnt = 0; cnt < conflictsno; ++cnt)
15779             iconf[cnt] = BYTE_GET (econf64[cnt]);
15780
15781           free (econf64);
15782         }
15783
15784       printf (_("\nSection '.conflict' contains %lu entries:\n"),
15785               (unsigned long) conflictsno);
15786       puts (_("  Num:    Index       Value  Name"));
15787
15788       for (cnt = 0; cnt < conflictsno; ++cnt)
15789         {
15790           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
15791
15792           if (iconf[cnt] >= num_dynamic_syms)
15793             printf (_("<corrupt symbol index>"));
15794           else
15795             {
15796               Elf_Internal_Sym * psym;
15797
15798               psym = & dynamic_symbols[iconf[cnt]];
15799               print_vma (psym->st_value, FULL_HEX);
15800               putchar (' ');
15801               if (VALID_DYNAMIC_NAME (psym->st_name))
15802                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15803               else
15804                 printf (_("<corrupt: %14ld>"), psym->st_name);
15805             }
15806           putchar ('\n');
15807         }
15808
15809       free (iconf);
15810     }
15811
15812   if (pltgot != 0 && local_gotno != 0)
15813     {
15814       bfd_vma ent, local_end, global_end;
15815       size_t i, offset;
15816       unsigned char * data;
15817       unsigned char * data_end;
15818       int addr_size;
15819
15820       ent = pltgot;
15821       addr_size = (is_32bit_elf ? 4 : 8);
15822       local_end = pltgot + local_gotno * addr_size;
15823
15824       /* PR binutils/17533 file: 012-111227-0.004  */
15825       if (symtabno < gotsym)
15826         {
15827           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15828                  (unsigned long) gotsym, (unsigned long) symtabno);
15829           return FALSE;
15830         }
15831
15832       global_end = local_end + (symtabno - gotsym) * addr_size;
15833       /* PR 17531: file: 54c91a34.  */
15834       if (global_end < local_end)
15835         {
15836           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15837           return FALSE;
15838         }
15839
15840       offset = offset_from_vma (file, pltgot, global_end - pltgot);
15841       data = (unsigned char *) get_data (NULL, file, offset,
15842                                          global_end - pltgot, 1,
15843                                          _("Global Offset Table data"));
15844       /* PR 12855: Null data is handled gracefully throughout.  */
15845       data_end = data + (global_end - pltgot);
15846
15847       printf (_("\nPrimary GOT:\n"));
15848       printf (_(" Canonical gp value: "));
15849       print_vma (pltgot + 0x7ff0, LONG_HEX);
15850       printf ("\n\n");
15851
15852       printf (_(" Reserved entries:\n"));
15853       printf (_("  %*s %10s %*s Purpose\n"),
15854               addr_size * 2, _("Address"), _("Access"),
15855               addr_size * 2, _("Initial"));
15856       ent = print_mips_got_entry (data, pltgot, ent, data_end);
15857       printf (_(" Lazy resolver\n"));
15858       if (ent == (bfd_vma) -1)
15859         goto got_print_fail;
15860
15861       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15862          This entry will be used by some runtime loaders, to store the
15863          module pointer.  Otherwise this is an ordinary local entry.
15864          PR 21344: Check for the entry being fully available before
15865          fetching it.  */
15866       if (data
15867           && data + ent - pltgot + addr_size <= data_end
15868           && (byte_get (data + ent - pltgot, addr_size)
15869               >> (addr_size * 8 - 1)) != 0)
15870         {
15871           ent = print_mips_got_entry (data, pltgot, ent, data_end);
15872           printf (_(" Module pointer (GNU extension)\n"));
15873           if (ent == (bfd_vma) -1)
15874             goto got_print_fail;
15875         }
15876       printf ("\n");
15877
15878       if (data != NULL && ent < local_end)
15879         {
15880           printf (_(" Local entries:\n"));
15881           printf ("  %*s %10s %*s\n",
15882                   addr_size * 2, _("Address"), _("Access"),
15883                   addr_size * 2, _("Initial"));
15884           while (ent < local_end)
15885             {
15886               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15887               printf ("\n");
15888               if (ent == (bfd_vma) -1)
15889                 goto got_print_fail;
15890             }
15891           printf ("\n");
15892         }
15893
15894       if (data != NULL && gotsym < symtabno)
15895         {
15896           int sym_width;
15897
15898           printf (_(" Global entries:\n"));
15899           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
15900                   addr_size * 2, _("Address"),
15901                   _("Access"),
15902                   addr_size * 2, _("Initial"),
15903                   addr_size * 2, _("Sym.Val."),
15904                   _("Type"),
15905                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
15906                   _("Ndx"), _("Name"));
15907
15908           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15909
15910           for (i = gotsym; i < symtabno; i++)
15911             {
15912               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15913               printf (" ");
15914
15915               if (dynamic_symbols == NULL)
15916                 printf (_("<no dynamic symbols>"));
15917               else if (i < num_dynamic_syms)
15918                 {
15919                   Elf_Internal_Sym * psym = dynamic_symbols + i;
15920
15921                   print_vma (psym->st_value, LONG_HEX);
15922                   printf (" %-7s %3s ",
15923                           get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15924                           get_symbol_index_type (psym->st_shndx));
15925
15926                   if (VALID_DYNAMIC_NAME (psym->st_name))
15927                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15928                   else
15929                     printf (_("<corrupt: %14ld>"), psym->st_name);
15930                 }
15931               else
15932                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15933                         (unsigned long) i);
15934
15935               printf ("\n");
15936               if (ent == (bfd_vma) -1)
15937                 break;
15938             }
15939           printf ("\n");
15940         }
15941
15942     got_print_fail:
15943       if (data)
15944         free (data);
15945     }
15946
15947   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15948     {
15949       bfd_vma ent, end;
15950       size_t offset, rel_offset;
15951       unsigned long count, i;
15952       unsigned char * data;
15953       int addr_size, sym_width;
15954       Elf_Internal_Rela * rels;
15955
15956       rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15957       if (pltrel == DT_RELA)
15958         {
15959           if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15960             return FALSE;
15961         }
15962       else
15963         {
15964           if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15965             return FALSE;
15966         }
15967
15968       ent = mips_pltgot;
15969       addr_size = (is_32bit_elf ? 4 : 8);
15970       end = mips_pltgot + (2 + count) * addr_size;
15971
15972       offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15973       data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15974                                          1, _("Procedure Linkage Table data"));
15975       if (data == NULL)
15976         return FALSE;
15977
15978       printf ("\nPLT GOT:\n\n");
15979       printf (_(" Reserved entries:\n"));
15980       printf (_("  %*s %*s Purpose\n"),
15981               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15982       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15983       printf (_(" PLT lazy resolver\n"));
15984       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15985       printf (_(" Module pointer\n"));
15986       printf ("\n");
15987
15988       printf (_(" Entries:\n"));
15989       printf ("  %*s %*s %*s %-7s %3s %s\n",
15990               addr_size * 2, _("Address"),
15991               addr_size * 2, _("Initial"),
15992               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15993       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15994       for (i = 0; i < count; i++)
15995         {
15996           unsigned long idx = get_reloc_symindex (rels[i].r_info);
15997
15998           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15999           printf (" ");
16000
16001           if (idx >= num_dynamic_syms)
16002             printf (_("<corrupt symbol index: %lu>"), idx);
16003           else
16004             {
16005               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16006
16007               print_vma (psym->st_value, LONG_HEX);
16008               printf (" %-7s %3s ",
16009                       get_symbol_type (ELF_ST_TYPE (psym->st_info)),
16010                       get_symbol_index_type (psym->st_shndx));
16011               if (VALID_DYNAMIC_NAME (psym->st_name))
16012                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16013               else
16014                 printf (_("<corrupt: %14ld>"), psym->st_name);
16015             }
16016           printf ("\n");
16017         }
16018       printf ("\n");
16019
16020       if (data)
16021         free (data);
16022       free (rels);
16023     }
16024
16025   return res;
16026 }
16027
16028 static bfd_boolean
16029 process_nds32_specific (FILE * file)
16030 {
16031   Elf_Internal_Shdr *sect = NULL;
16032
16033   sect = find_section (".nds32_e_flags");
16034   if (sect != NULL)
16035     {
16036       unsigned int *flag;
16037
16038       printf ("\nNDS32 elf flags section:\n");
16039       flag = get_data (NULL, file, sect->sh_offset, 1,
16040                        sect->sh_size, _("NDS32 elf flags section"));
16041
16042       if (! flag)
16043         return FALSE;
16044
16045       switch ((*flag) & 0x3)
16046         {
16047         case 0:
16048           printf ("(VEC_SIZE):\tNo entry.\n");
16049           break;
16050         case 1:
16051           printf ("(VEC_SIZE):\t4 bytes\n");
16052           break;
16053         case 2:
16054           printf ("(VEC_SIZE):\t16 bytes\n");
16055           break;
16056         case 3:
16057           printf ("(VEC_SIZE):\treserved\n");
16058           break;
16059         }
16060     }
16061
16062   return TRUE;
16063 }
16064
16065 static bfd_boolean
16066 process_gnu_liblist (FILE * file)
16067 {
16068   Elf_Internal_Shdr * section;
16069   Elf_Internal_Shdr * string_sec;
16070   Elf32_External_Lib * elib;
16071   char * strtab;
16072   size_t strtab_size;
16073   size_t cnt;
16074   unsigned i;
16075   bfd_boolean res = TRUE;
16076
16077   if (! do_arch)
16078     return TRUE;
16079
16080   for (i = 0, section = section_headers;
16081        i < elf_header.e_shnum;
16082        i++, section++)
16083     {
16084       switch (section->sh_type)
16085         {
16086         case SHT_GNU_LIBLIST:
16087           if (section->sh_link >= elf_header.e_shnum)
16088             break;
16089
16090           elib = (Elf32_External_Lib *)
16091               get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16092                         _("liblist section data"));
16093
16094           if (elib == NULL)
16095             {
16096               res = FALSE;
16097               break;
16098             }
16099
16100           string_sec = section_headers + section->sh_link;
16101           strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16102                                       string_sec->sh_size,
16103                                       _("liblist string table"));
16104           if (strtab == NULL
16105               || section->sh_entsize != sizeof (Elf32_External_Lib))
16106             {
16107               free (elib);
16108               free (strtab);
16109               res = FALSE;
16110               break;
16111             }
16112           strtab_size = string_sec->sh_size;
16113
16114           printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16115                   printable_section_name (section),
16116                   (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16117
16118           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16119
16120           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16121                ++cnt)
16122             {
16123               Elf32_Lib liblist;
16124               time_t atime;
16125               char timebuf[128];
16126               struct tm * tmp;
16127
16128               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16129               atime = BYTE_GET (elib[cnt].l_time_stamp);
16130               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16131               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16132               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16133
16134               tmp = gmtime (&atime);
16135               snprintf (timebuf, sizeof (timebuf),
16136                         "%04u-%02u-%02uT%02u:%02u:%02u",
16137                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16138                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16139
16140               printf ("%3lu: ", (unsigned long) cnt);
16141               if (do_wide)
16142                 printf ("%-20s", liblist.l_name < strtab_size
16143                         ? strtab + liblist.l_name : _("<corrupt>"));
16144               else
16145                 printf ("%-20.20s", liblist.l_name < strtab_size
16146                         ? strtab + liblist.l_name : _("<corrupt>"));
16147               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16148                       liblist.l_version, liblist.l_flags);
16149             }
16150
16151           free (elib);
16152           free (strtab);
16153         }
16154     }
16155
16156   return res;
16157 }
16158
16159 static const char *
16160 get_note_type (unsigned e_type)
16161 {
16162   static char buff[64];
16163
16164   if (elf_header.e_type == ET_CORE)
16165     switch (e_type)
16166       {
16167       case NT_AUXV:
16168         return _("NT_AUXV (auxiliary vector)");
16169       case NT_PRSTATUS:
16170         return _("NT_PRSTATUS (prstatus structure)");
16171       case NT_FPREGSET:
16172         return _("NT_FPREGSET (floating point registers)");
16173       case NT_PRPSINFO:
16174         return _("NT_PRPSINFO (prpsinfo structure)");
16175       case NT_TASKSTRUCT:
16176         return _("NT_TASKSTRUCT (task structure)");
16177       case NT_PRXFPREG:
16178         return _("NT_PRXFPREG (user_xfpregs structure)");
16179       case NT_PPC_VMX:
16180         return _("NT_PPC_VMX (ppc Altivec registers)");
16181       case NT_PPC_VSX:
16182         return _("NT_PPC_VSX (ppc VSX registers)");
16183       case NT_PPC_TAR:
16184         return _("NT_PPC_TAR (ppc TAR register)");
16185       case NT_PPC_PPR:
16186         return _("NT_PPC_PPR (ppc PPR register)");
16187       case NT_PPC_DSCR:
16188         return _("NT_PPC_DSCR (ppc DSCR register)");
16189       case NT_PPC_EBB:
16190         return _("NT_PPC_EBB (ppc EBB registers)");
16191       case NT_PPC_PMU:
16192         return _("NT_PPC_PMU (ppc PMU registers)");
16193       case NT_PPC_TM_CGPR:
16194         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16195       case NT_PPC_TM_CFPR:
16196         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16197       case NT_PPC_TM_CVMX:
16198         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16199       case NT_PPC_TM_CVSX:
16200         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16201       case NT_PPC_TM_SPR:
16202         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16203       case NT_PPC_TM_CTAR:
16204         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16205       case NT_PPC_TM_CPPR:
16206         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16207       case NT_PPC_TM_CDSCR:
16208         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16209       case NT_386_TLS:
16210         return _("NT_386_TLS (x86 TLS information)");
16211       case NT_386_IOPERM:
16212         return _("NT_386_IOPERM (x86 I/O permissions)");
16213       case NT_X86_XSTATE:
16214         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16215       case NT_S390_HIGH_GPRS:
16216         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16217       case NT_S390_TIMER:
16218         return _("NT_S390_TIMER (s390 timer register)");
16219       case NT_S390_TODCMP:
16220         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16221       case NT_S390_TODPREG:
16222         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16223       case NT_S390_CTRS:
16224         return _("NT_S390_CTRS (s390 control registers)");
16225       case NT_S390_PREFIX:
16226         return _("NT_S390_PREFIX (s390 prefix register)");
16227       case NT_S390_LAST_BREAK:
16228         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16229       case NT_S390_SYSTEM_CALL:
16230         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16231       case NT_S390_TDB:
16232         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16233       case NT_S390_VXRS_LOW:
16234         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16235       case NT_S390_VXRS_HIGH:
16236         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16237       case NT_S390_GS_CB:
16238         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16239       case NT_S390_GS_BC:
16240         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16241       case NT_ARM_VFP:
16242         return _("NT_ARM_VFP (arm VFP registers)");
16243       case NT_ARM_TLS:
16244         return _("NT_ARM_TLS (AArch TLS registers)");
16245       case NT_ARM_HW_BREAK:
16246         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16247       case NT_ARM_HW_WATCH:
16248         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16249       case NT_PSTATUS:
16250         return _("NT_PSTATUS (pstatus structure)");
16251       case NT_FPREGS:
16252         return _("NT_FPREGS (floating point registers)");
16253       case NT_PSINFO:
16254         return _("NT_PSINFO (psinfo structure)");
16255       case NT_LWPSTATUS:
16256         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16257       case NT_LWPSINFO:
16258         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16259       case NT_WIN32PSTATUS:
16260         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16261       case NT_SIGINFO:
16262         return _("NT_SIGINFO (siginfo_t data)");
16263       case NT_FILE:
16264         return _("NT_FILE (mapped files)");
16265       default:
16266         break;
16267       }
16268   else
16269     switch (e_type)
16270       {
16271       case NT_VERSION:
16272         return _("NT_VERSION (version)");
16273       case NT_ARCH:
16274         return _("NT_ARCH (architecture)");
16275       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16276         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16277       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16278         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16279       default:
16280         break;
16281       }
16282
16283   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16284   return buff;
16285 }
16286
16287 static bfd_boolean
16288 print_core_note (Elf_Internal_Note *pnote)
16289 {
16290   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16291   bfd_vma count, page_size;
16292   unsigned char *descdata, *filenames, *descend;
16293
16294   if (pnote->type != NT_FILE)
16295     {
16296       if (do_wide)
16297         printf ("\n");
16298       return TRUE;
16299     }
16300
16301 #ifndef BFD64
16302   if (!is_32bit_elf)
16303     {
16304       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16305       /* Still "successful".  */
16306       return TRUE;
16307     }
16308 #endif
16309
16310   if (pnote->descsz < 2 * addr_size)
16311     {
16312       error (_("    Malformed note - too short for header\n"));
16313       return FALSE;
16314     }
16315
16316   descdata = (unsigned char *) pnote->descdata;
16317   descend = descdata + pnote->descsz;
16318
16319   if (descdata[pnote->descsz - 1] != '\0')
16320     {
16321       error (_("    Malformed note - does not end with \\0\n"));
16322       return FALSE;
16323     }
16324
16325   count = byte_get (descdata, addr_size);
16326   descdata += addr_size;
16327
16328   page_size = byte_get (descdata, addr_size);
16329   descdata += addr_size;
16330
16331   if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16332     {
16333       error (_("    Malformed note - too short for supplied file count\n"));
16334       return FALSE;
16335     }
16336
16337   printf (_("    Page size: "));
16338   print_vma (page_size, DEC);
16339   printf ("\n");
16340
16341   printf (_("    %*s%*s%*s\n"),
16342           (int) (2 + 2 * addr_size), _("Start"),
16343           (int) (4 + 2 * addr_size), _("End"),
16344           (int) (4 + 2 * addr_size), _("Page Offset"));
16345   filenames = descdata + count * 3 * addr_size;
16346   while (count-- > 0)
16347     {
16348       bfd_vma start, end, file_ofs;
16349
16350       if (filenames == descend)
16351         {
16352           error (_("    Malformed note - filenames end too early\n"));
16353           return FALSE;
16354         }
16355
16356       start = byte_get (descdata, addr_size);
16357       descdata += addr_size;
16358       end = byte_get (descdata, addr_size);
16359       descdata += addr_size;
16360       file_ofs = byte_get (descdata, addr_size);
16361       descdata += addr_size;
16362
16363       printf ("    ");
16364       print_vma (start, FULL_HEX);
16365       printf ("  ");
16366       print_vma (end, FULL_HEX);
16367       printf ("  ");
16368       print_vma (file_ofs, FULL_HEX);
16369       printf ("\n        %s\n", filenames);
16370
16371       filenames += 1 + strlen ((char *) filenames);
16372     }
16373
16374   return TRUE;
16375 }
16376
16377 static const char *
16378 get_gnu_elf_note_type (unsigned e_type)
16379 {
16380   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16381   switch (e_type)
16382     {
16383     case NT_GNU_ABI_TAG:
16384       return _("NT_GNU_ABI_TAG (ABI version tag)");
16385     case NT_GNU_HWCAP:
16386       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16387     case NT_GNU_BUILD_ID:
16388       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16389     case NT_GNU_GOLD_VERSION:
16390       return _("NT_GNU_GOLD_VERSION (gold version)");
16391     case NT_GNU_PROPERTY_TYPE_0:
16392       return _("NT_GNU_PROPERTY_TYPE_0");
16393     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16394       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16395     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16396       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16397     default:
16398       {
16399         static char buff[64];
16400
16401         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16402         return buff;
16403       }
16404     }
16405 }
16406
16407 static void
16408 decode_x86_isa (unsigned int bitmask)
16409 {
16410   while (bitmask)
16411     {
16412       unsigned int bit = bitmask & (- bitmask);
16413
16414       bitmask &= ~ bit;
16415       switch (bit)
16416         {
16417         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16418         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16419         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16420         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16421         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16422         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16423         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16424         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16425         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16426         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16427         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16428         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16429         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16430         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16431         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16432         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16433         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16434         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16435         default: printf (_("<unknown: %x>"), bit); break;
16436         }
16437       if (bitmask)
16438         printf (", ");
16439     }
16440 }
16441
16442 static void
16443 decode_x86_feature (unsigned int type, unsigned int bitmask)
16444 {
16445   while (bitmask)
16446     {
16447       unsigned int bit = bitmask & (- bitmask);
16448
16449       bitmask &= ~ bit;
16450       switch (bit)
16451         {
16452         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16453           switch (type)
16454             {
16455             case GNU_PROPERTY_X86_FEATURE_1_AND:
16456               printf ("IBT");
16457               break;
16458             default:
16459               /* This should never happen.  */
16460               abort ();
16461             }
16462           break;
16463         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16464           switch (type)
16465             {
16466             case GNU_PROPERTY_X86_FEATURE_1_AND:
16467               printf ("SHSTK");
16468               break;
16469             default:
16470               /* This should never happen.  */
16471               abort ();
16472             }
16473           break;
16474         default:
16475           printf (_("<unknown: %x>"), bit);
16476           break;
16477         }
16478       if (bitmask)
16479         printf (", ");
16480     }
16481 }
16482
16483 static void
16484 print_gnu_property_note (Elf_Internal_Note * pnote)
16485 {
16486   unsigned char * ptr = (unsigned char *) pnote->descdata;
16487   unsigned char * ptr_end = ptr + pnote->descsz;
16488   unsigned int    size = is_32bit_elf ? 4 : 8;
16489
16490   printf (_("      Properties: "));
16491
16492   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16493     {
16494       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16495       return;
16496     }
16497
16498   while (1)
16499     {
16500       unsigned int j;
16501       unsigned int type = byte_get (ptr, 4);
16502       unsigned int datasz = byte_get (ptr + 4, 4);
16503
16504       ptr += 8;
16505
16506       if ((ptr + datasz) > ptr_end)
16507         {
16508           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16509                   type, datasz);
16510           break;
16511         }
16512
16513       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16514         {
16515           if (elf_header.e_machine == EM_X86_64
16516               || elf_header.e_machine == EM_IAMCU
16517               || elf_header.e_machine == EM_386)
16518             {
16519               switch (type)
16520                 {
16521                 case GNU_PROPERTY_X86_ISA_1_USED:
16522                   printf ("x86 ISA used: ");
16523                   if (datasz != 4)
16524                     printf (_("<corrupt length: %#x> "), datasz);
16525                   else
16526                     decode_x86_isa (byte_get (ptr, 4));
16527                   goto next;
16528
16529                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16530                   printf ("x86 ISA needed: ");
16531                   if (datasz != 4)
16532                     printf (_("<corrupt length: %#x> "), datasz);
16533                   else
16534                     decode_x86_isa (byte_get (ptr, 4));
16535                   goto next;
16536
16537                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16538                   printf ("x86 feature: ");
16539                   if (datasz != 4)
16540                     printf (_("<corrupt length: %#x> "), datasz);
16541                   else
16542                     decode_x86_feature (type, byte_get (ptr, 4));
16543                   goto next;
16544
16545                 default:
16546                   break;
16547                 }
16548             }
16549         }
16550       else
16551         {
16552           switch (type)
16553             {
16554             case GNU_PROPERTY_STACK_SIZE:
16555               printf (_("stack size: "));
16556               if (datasz != size)
16557                 printf (_("<corrupt length: %#x> "), datasz);
16558               else
16559                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16560               goto next;
16561
16562             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16563               printf ("no copy on protected ");
16564               if (datasz)
16565                 printf (_("<corrupt length: %#x> "), datasz);
16566               goto next;
16567
16568             default:
16569               break;
16570             }
16571         }
16572
16573       if (type < GNU_PROPERTY_LOPROC)
16574         printf (_("<unknown type %#x data: "), type);
16575       else if (type < GNU_PROPERTY_LOUSER)
16576         printf (_("<procesor-specific type %#x data: "), type);
16577       else
16578         printf (_("<application-specific type %#x data: "), type);
16579       for (j = 0; j < datasz; ++j)
16580         printf ("%02x ", ptr[j] & 0xff);
16581       printf (">");
16582
16583 next:
16584       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16585       if (ptr == ptr_end)
16586         break;
16587       else
16588         {
16589           if (do_wide)
16590             printf (", ");
16591           else
16592             printf ("\n\t");
16593         }
16594
16595       if (ptr > (ptr_end - 8))
16596         {
16597           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16598           break;
16599         }
16600     }
16601
16602   printf ("\n");
16603 }
16604
16605 static bfd_boolean
16606 print_gnu_note (Elf_Internal_Note *pnote)
16607 {
16608   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16609   switch (pnote->type)
16610     {
16611     case NT_GNU_BUILD_ID:
16612       {
16613         unsigned long i;
16614
16615         printf (_("    Build ID: "));
16616         for (i = 0; i < pnote->descsz; ++i)
16617           printf ("%02x", pnote->descdata[i] & 0xff);
16618         printf ("\n");
16619       }
16620       break;
16621
16622     case NT_GNU_ABI_TAG:
16623       {
16624         unsigned long os, major, minor, subminor;
16625         const char *osname;
16626
16627         /* PR 17531: file: 030-599401-0.004.  */
16628         if (pnote->descsz < 16)
16629           {
16630             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16631             break;
16632           }
16633
16634         os = byte_get ((unsigned char *) pnote->descdata, 4);
16635         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16636         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16637         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16638
16639         switch (os)
16640           {
16641           case GNU_ABI_TAG_LINUX:
16642             osname = "Linux";
16643             break;
16644           case GNU_ABI_TAG_HURD:
16645             osname = "Hurd";
16646             break;
16647           case GNU_ABI_TAG_SOLARIS:
16648             osname = "Solaris";
16649             break;
16650           case GNU_ABI_TAG_FREEBSD:
16651             osname = "FreeBSD";
16652             break;
16653           case GNU_ABI_TAG_NETBSD:
16654             osname = "NetBSD";
16655             break;
16656           case GNU_ABI_TAG_SYLLABLE:
16657             osname = "Syllable";
16658             break;
16659           case GNU_ABI_TAG_NACL:
16660             osname = "NaCl";
16661             break;
16662           default:
16663             osname = "Unknown";
16664             break;
16665           }
16666
16667         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16668                 major, minor, subminor);
16669       }
16670       break;
16671
16672     case NT_GNU_GOLD_VERSION:
16673       {
16674         unsigned long i;
16675
16676         printf (_("    Version: "));
16677         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16678           printf ("%c", pnote->descdata[i]);
16679         printf ("\n");
16680       }
16681       break;
16682
16683     case NT_GNU_HWCAP:
16684       {
16685         unsigned long num_entries, mask;
16686
16687         /* Hardware capabilities information.  Word 0 is the number of entries.
16688            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
16689            is a series of entries, where each entry is a single byte followed
16690            by a nul terminated string.  The byte gives the bit number to test
16691            if enabled in the bitmask.  */
16692         printf (_("      Hardware Capabilities: "));
16693         if (pnote->descsz < 8)
16694           {
16695             error (_("<corrupt GNU_HWCAP>\n"));
16696             return FALSE;
16697           }
16698         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16699         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16700         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16701         /* FIXME: Add code to display the entries... */
16702       }
16703       break;
16704
16705     case NT_GNU_PROPERTY_TYPE_0:
16706       print_gnu_property_note (pnote);
16707       break;
16708
16709     default:
16710       /* Handle unrecognised types.  An error message should have already been
16711          created by get_gnu_elf_note_type(), so all that we need to do is to
16712          display the data.  */
16713       {
16714         unsigned long i;
16715
16716         printf (_("    Description data: "));
16717         for (i = 0; i < pnote->descsz; ++i)
16718           printf ("%02x ", pnote->descdata[i] & 0xff);
16719         printf ("\n");
16720       }
16721       break;
16722     }
16723
16724   return TRUE;
16725 }
16726
16727 static const char *
16728 get_v850_elf_note_type (enum v850_notes n_type)
16729 {
16730   static char buff[64];
16731
16732   switch (n_type)
16733     {
16734     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
16735     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
16736     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
16737     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
16738     case V850_NOTE_CACHE_INFO: return _("Use of cache");
16739     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
16740     default:
16741       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16742       return buff;
16743     }
16744 }
16745
16746 static bfd_boolean
16747 print_v850_note (Elf_Internal_Note * pnote)
16748 {
16749   unsigned int val;
16750
16751   if (pnote->descsz != 4)
16752     return FALSE;
16753
16754   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16755
16756   if (val == 0)
16757     {
16758       printf (_("not set\n"));
16759       return TRUE;
16760     }
16761
16762   switch (pnote->type)
16763     {
16764     case V850_NOTE_ALIGNMENT:
16765       switch (val)
16766         {
16767         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16768         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16769         }
16770       break;
16771
16772     case V850_NOTE_DATA_SIZE:
16773       switch (val)
16774         {
16775         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16776         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16777         }
16778       break;
16779
16780     case V850_NOTE_FPU_INFO:
16781       switch (val)
16782         {
16783         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16784         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16785         }
16786       break;
16787
16788     case V850_NOTE_MMU_INFO:
16789     case V850_NOTE_CACHE_INFO:
16790     case V850_NOTE_SIMD_INFO:
16791       if (val == EF_RH850_SIMD)
16792         {
16793           printf (_("yes\n"));
16794           return TRUE;
16795         }
16796       break;
16797
16798     default:
16799       /* An 'unknown note type' message will already have been displayed.  */
16800       break;
16801     }
16802
16803   printf (_("unknown value: %x\n"), val);
16804   return FALSE;
16805 }
16806
16807 static bfd_boolean
16808 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16809 {
16810   unsigned int version;
16811
16812   switch (pnote->type)
16813     {
16814     case NT_NETBSD_IDENT:
16815       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16816       if ((version / 10000) % 100)
16817         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16818                 version, version / 100000000, (version / 1000000) % 100,
16819                 (version / 10000) % 100 > 26 ? "Z" : "",
16820                 'A' + (version / 10000) % 26);
16821       else
16822         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16823                 version, version / 100000000, (version / 1000000) % 100,
16824                 (version / 100) % 100);
16825       return TRUE;
16826
16827     case NT_NETBSD_MARCH:
16828       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16829               pnote->descdata);
16830       return TRUE;
16831
16832     default:
16833       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16834               pnote->type);
16835       return FALSE;
16836     }
16837 }
16838
16839 static const char *
16840 get_freebsd_elfcore_note_type (unsigned e_type)
16841 {
16842   switch (e_type)
16843     {
16844     case NT_FREEBSD_THRMISC:
16845       return _("NT_THRMISC (thrmisc structure)");
16846     case NT_FREEBSD_PROCSTAT_PROC:
16847       return _("NT_PROCSTAT_PROC (proc data)");
16848     case NT_FREEBSD_PROCSTAT_FILES:
16849       return _("NT_PROCSTAT_FILES (files data)");
16850     case NT_FREEBSD_PROCSTAT_VMMAP:
16851       return _("NT_PROCSTAT_VMMAP (vmmap data)");
16852     case NT_FREEBSD_PROCSTAT_GROUPS:
16853       return _("NT_PROCSTAT_GROUPS (groups data)");
16854     case NT_FREEBSD_PROCSTAT_UMASK:
16855       return _("NT_PROCSTAT_UMASK (umask data)");
16856     case NT_FREEBSD_PROCSTAT_RLIMIT:
16857       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16858     case NT_FREEBSD_PROCSTAT_OSREL:
16859       return _("NT_PROCSTAT_OSREL (osreldate data)");
16860     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16861       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16862     case NT_FREEBSD_PROCSTAT_AUXV:
16863       return _("NT_PROCSTAT_AUXV (auxv data)");
16864     case NT_FREEBSD_PTLWPINFO:
16865       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16866     }
16867   return get_note_type (e_type);
16868 }
16869
16870 static const char *
16871 get_netbsd_elfcore_note_type (unsigned e_type)
16872 {
16873   static char buff[64];
16874
16875   if (e_type == NT_NETBSDCORE_PROCINFO)
16876     {
16877       /* NetBSD core "procinfo" structure.  */
16878       return _("NetBSD procinfo structure");
16879     }
16880
16881   /* As of Jan 2002 there are no other machine-independent notes
16882      defined for NetBSD core files.  If the note type is less
16883      than the start of the machine-dependent note types, we don't
16884      understand it.  */
16885
16886   if (e_type < NT_NETBSDCORE_FIRSTMACH)
16887     {
16888       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16889       return buff;
16890     }
16891
16892   switch (elf_header.e_machine)
16893     {
16894     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16895        and PT_GETFPREGS == mach+2.  */
16896
16897     case EM_OLD_ALPHA:
16898     case EM_ALPHA:
16899     case EM_SPARC:
16900     case EM_SPARC32PLUS:
16901     case EM_SPARCV9:
16902       switch (e_type)
16903         {
16904         case NT_NETBSDCORE_FIRSTMACH + 0:
16905           return _("PT_GETREGS (reg structure)");
16906         case NT_NETBSDCORE_FIRSTMACH + 2:
16907           return _("PT_GETFPREGS (fpreg structure)");
16908         default:
16909           break;
16910         }
16911       break;
16912
16913     /* On all other arch's, PT_GETREGS == mach+1 and
16914        PT_GETFPREGS == mach+3.  */
16915     default:
16916       switch (e_type)
16917         {
16918         case NT_NETBSDCORE_FIRSTMACH + 1:
16919           return _("PT_GETREGS (reg structure)");
16920         case NT_NETBSDCORE_FIRSTMACH + 3:
16921           return _("PT_GETFPREGS (fpreg structure)");
16922         default:
16923           break;
16924         }
16925     }
16926
16927   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16928             e_type - NT_NETBSDCORE_FIRSTMACH);
16929   return buff;
16930 }
16931
16932 static const char *
16933 get_stapsdt_note_type (unsigned e_type)
16934 {
16935   static char buff[64];
16936
16937   switch (e_type)
16938     {
16939     case NT_STAPSDT:
16940       return _("NT_STAPSDT (SystemTap probe descriptors)");
16941
16942     default:
16943       break;
16944     }
16945
16946   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16947   return buff;
16948 }
16949
16950 static bfd_boolean
16951 print_stapsdt_note (Elf_Internal_Note *pnote)
16952 {
16953   int addr_size = is_32bit_elf ? 4 : 8;
16954   char *data = pnote->descdata;
16955   char *data_end = pnote->descdata + pnote->descsz;
16956   bfd_vma pc, base_addr, semaphore;
16957   char *provider, *probe, *arg_fmt;
16958
16959   pc = byte_get ((unsigned char *) data, addr_size);
16960   data += addr_size;
16961   base_addr = byte_get ((unsigned char *) data, addr_size);
16962   data += addr_size;
16963   semaphore = byte_get ((unsigned char *) data, addr_size);
16964   data += addr_size;
16965
16966   provider = data;
16967   data += strlen (data) + 1;
16968   probe = data;
16969   data += strlen (data) + 1;
16970   arg_fmt = data;
16971   data += strlen (data) + 1;
16972
16973   printf (_("    Provider: %s\n"), provider);
16974   printf (_("    Name: %s\n"), probe);
16975   printf (_("    Location: "));
16976   print_vma (pc, FULL_HEX);
16977   printf (_(", Base: "));
16978   print_vma (base_addr, FULL_HEX);
16979   printf (_(", Semaphore: "));
16980   print_vma (semaphore, FULL_HEX);
16981   printf ("\n");
16982   printf (_("    Arguments: %s\n"), arg_fmt);
16983
16984   return data == data_end;
16985 }
16986
16987 static const char *
16988 get_ia64_vms_note_type (unsigned e_type)
16989 {
16990   static char buff[64];
16991
16992   switch (e_type)
16993     {
16994     case NT_VMS_MHD:
16995       return _("NT_VMS_MHD (module header)");
16996     case NT_VMS_LNM:
16997       return _("NT_VMS_LNM (language name)");
16998     case NT_VMS_SRC:
16999       return _("NT_VMS_SRC (source files)");
17000     case NT_VMS_TITLE:
17001       return "NT_VMS_TITLE";
17002     case NT_VMS_EIDC:
17003       return _("NT_VMS_EIDC (consistency check)");
17004     case NT_VMS_FPMODE:
17005       return _("NT_VMS_FPMODE (FP mode)");
17006     case NT_VMS_LINKTIME:
17007       return "NT_VMS_LINKTIME";
17008     case NT_VMS_IMGNAM:
17009       return _("NT_VMS_IMGNAM (image name)");
17010     case NT_VMS_IMGID:
17011       return _("NT_VMS_IMGID (image id)");
17012     case NT_VMS_LINKID:
17013       return _("NT_VMS_LINKID (link id)");
17014     case NT_VMS_IMGBID:
17015       return _("NT_VMS_IMGBID (build id)");
17016     case NT_VMS_GSTNAM:
17017       return _("NT_VMS_GSTNAM (sym table name)");
17018     case NT_VMS_ORIG_DYN:
17019       return "NT_VMS_ORIG_DYN";
17020     case NT_VMS_PATCHTIME:
17021       return "NT_VMS_PATCHTIME";
17022     default:
17023       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17024       return buff;
17025     }
17026 }
17027
17028 static bfd_boolean
17029 print_ia64_vms_note (Elf_Internal_Note * pnote)
17030 {
17031   switch (pnote->type)
17032     {
17033     case NT_VMS_MHD:
17034       if (pnote->descsz > 36)
17035         {
17036           size_t l = strlen (pnote->descdata + 34);
17037           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17038           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17039           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17040           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17041         }
17042       else
17043         printf (_("    Invalid size\n"));
17044       break;
17045     case NT_VMS_LNM:
17046       printf (_("   Language: %s\n"), pnote->descdata);
17047       break;
17048 #ifdef BFD64
17049     case NT_VMS_FPMODE:
17050       printf (_("   Floating Point mode: "));
17051       printf ("0x%016" BFD_VMA_FMT "x\n",
17052               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17053       break;
17054     case NT_VMS_LINKTIME:
17055       printf (_("   Link time: "));
17056       print_vms_time
17057         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17058       printf ("\n");
17059       break;
17060     case NT_VMS_PATCHTIME:
17061       printf (_("   Patch time: "));
17062       print_vms_time
17063         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17064       printf ("\n");
17065       break;
17066     case NT_VMS_ORIG_DYN:
17067       printf (_("   Major id: %u,  minor id: %u\n"),
17068               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17069               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17070       printf (_("   Last modified  : "));
17071       print_vms_time
17072         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17073       printf (_("\n   Link flags  : "));
17074       printf ("0x%016" BFD_VMA_FMT "x\n",
17075               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17076       printf (_("   Header flags: 0x%08x\n"),
17077               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17078       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17079       break;
17080 #endif
17081     case NT_VMS_IMGNAM:
17082       printf (_("    Image name: %s\n"), pnote->descdata);
17083       break;
17084     case NT_VMS_GSTNAM:
17085       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17086       break;
17087     case NT_VMS_IMGID:
17088       printf (_("    Image id: %s\n"), pnote->descdata);
17089       break;
17090     case NT_VMS_LINKID:
17091       printf (_("    Linker id: %s\n"), pnote->descdata);
17092       break;
17093     default:
17094       return FALSE;
17095     }
17096   return TRUE;
17097 }
17098
17099 /* Print the name of the symbol associated with a build attribute
17100    that is attached to address OFFSET.  */
17101
17102 static bfd_boolean
17103 print_symbol_for_build_attribute (FILE *         file,
17104                                   unsigned long  offset,
17105                                   bfd_boolean    is_open_attr)
17106 {
17107   static FILE *             saved_file = NULL;
17108   static char *             strtab;
17109   static unsigned long      strtablen;
17110   static Elf_Internal_Sym * symtab;
17111   static unsigned long      nsyms;
17112   Elf_Internal_Sym *        saved_sym = NULL;
17113   Elf_Internal_Sym *        sym;
17114
17115   if (section_headers != NULL
17116       && (saved_file == NULL || file != saved_file))
17117     {
17118       Elf_Internal_Shdr * symsec;
17119
17120       /* Load the symbol and string sections.  */
17121       for (symsec = section_headers;
17122            symsec < section_headers + elf_header.e_shnum;
17123            symsec ++)
17124         {
17125           if (symsec->sh_type == SHT_SYMTAB)
17126             {
17127               symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17128
17129               if (symsec->sh_link < elf_header.e_shnum)
17130                 {
17131                   Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17132
17133                   strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17134                                               1, strtab_sec->sh_size,
17135                                               _("string table"));
17136                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17137                 }
17138             }
17139         }
17140       saved_file = file;
17141     }
17142
17143   if (symtab == NULL || strtab == NULL)
17144     {
17145       printf ("\n");
17146       return FALSE;
17147     }
17148
17149   /* Find a symbol whose value matches offset.  */
17150   for (sym = symtab; sym < symtab + nsyms; sym ++)
17151     if (sym->st_value == offset)
17152       {
17153         if (sym->st_name >= strtablen)
17154           /* Huh ?  This should not happen.  */
17155           continue;
17156
17157         if (strtab[sym->st_name] == 0)
17158           continue;
17159
17160         if (is_open_attr)
17161           {
17162             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17163                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17164                FUNC symbols entirely.  */
17165             switch (ELF_ST_TYPE (sym->st_info))
17166               {
17167               case STT_FILE:
17168                 saved_sym = sym;
17169                 /* We can stop searching now.  */
17170                 sym = symtab + nsyms;
17171                 continue;
17172
17173               case STT_OBJECT:
17174                 saved_sym = sym;
17175                 continue;
17176
17177               case STT_FUNC:
17178                 /* Ignore function symbols.  */
17179                 continue;
17180
17181               default:
17182                 break;
17183               }
17184
17185             switch (ELF_ST_BIND (sym->st_info))
17186               {
17187               case STB_GLOBAL:
17188                 if (saved_sym == NULL
17189                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17190                   saved_sym = sym;
17191                 break;
17192
17193               case STB_LOCAL:
17194                 if (saved_sym == NULL)
17195                   saved_sym = sym;
17196                 break;
17197
17198               default:
17199                 break;
17200               }
17201           }
17202         else
17203           {
17204             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17205               continue;
17206
17207             saved_sym = sym;
17208             break;
17209           }
17210       }
17211
17212   printf (" (%s: %s)\n",
17213           is_open_attr ? _("file") : _("func"),
17214           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17215   return TRUE;
17216 }
17217
17218 static bfd_boolean
17219 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17220                                        FILE *              file)
17221 {
17222   static unsigned long global_offset = 0;
17223   unsigned long        offset;
17224   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17225   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17226
17227   if (pnote->descsz == 0)
17228     {
17229       if (is_open_attr)
17230         {
17231           printf (_("    Applies from offset %#lx\n"), global_offset);
17232           return TRUE;
17233         }
17234       else
17235         {
17236           printf (_("    Applies to func at %#lx"), global_offset);
17237           return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17238         }
17239     }
17240
17241   if (pnote->descsz != desc_size)
17242     {
17243       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17244       printf (_("    <invalid descsz>"));
17245       return FALSE;
17246     }
17247
17248   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17249
17250   if (is_open_attr)
17251     {
17252       printf (_("    Applies from offset %#lx"), offset);
17253       global_offset = offset;
17254     }
17255   else
17256     {
17257       printf (_("    Applies to func at %#lx"), offset);
17258     }
17259
17260   return print_symbol_for_build_attribute (file, offset, is_open_attr);
17261 }
17262
17263 static bfd_boolean
17264 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17265 {
17266   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17267   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17268   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17269   char         name_type;
17270   char         name_attribute;
17271   const char * expected_types;
17272   const char * name = pnote->namedata;
17273   const char * text;
17274   signed int   left;
17275
17276   if (name == NULL || pnote->namesz < 2)
17277     {
17278       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17279       print_symbol (-20, _("  <corrupt name>"));
17280       return FALSE;
17281     }
17282
17283   left = 20;
17284
17285   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17286   if (name[0] == 'G' && name[1] == 'A')
17287     {
17288       printf ("GA");
17289       name += 2;
17290       left -= 2;
17291     }
17292
17293   switch ((name_type = * name))
17294     {
17295     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17296     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17297     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17298     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17299       printf ("%c", * name);
17300       left --;
17301       break;
17302     default:
17303       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17304       print_symbol (-20, _("<unknown name type>"));
17305       return FALSE;
17306     }
17307
17308   ++ name;
17309   text = NULL;
17310
17311   switch ((name_attribute = * name))
17312     {
17313     case GNU_BUILD_ATTRIBUTE_VERSION:
17314       text = _("<version>");
17315       expected_types = string_expected;
17316       ++ name;
17317       break;
17318     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17319       text = _("<stack prot>");
17320       expected_types = "!+*";
17321       ++ name;
17322       break;
17323     case GNU_BUILD_ATTRIBUTE_RELRO:
17324       text = _("<relro>");
17325       expected_types = bool_expected;
17326       ++ name;
17327       break;
17328     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17329       text = _("<stack size>");
17330       expected_types = number_expected;
17331       ++ name;
17332       break;
17333     case GNU_BUILD_ATTRIBUTE_TOOL:
17334       text = _("<tool>");
17335       expected_types = string_expected;
17336       ++ name;
17337       break;
17338     case GNU_BUILD_ATTRIBUTE_ABI:
17339       text = _("<ABI>");
17340       expected_types = "$*";
17341       ++ name;
17342       break;
17343     case GNU_BUILD_ATTRIBUTE_PIC:
17344       text = _("<PIC>");
17345       expected_types = number_expected;
17346       ++ name;
17347       break;
17348     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17349       text = _("<short enum>");
17350       expected_types = bool_expected;
17351       ++ name;
17352       break;
17353     default:
17354       if (ISPRINT (* name))
17355         {
17356           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17357
17358           if (len > left && ! do_wide)
17359             len = left;
17360           printf ("%.*s:", len, name);
17361           left -= len;
17362           name += len;
17363         }
17364       else
17365         {
17366           static char tmpbuf [128];
17367
17368           error (_("unrecognised byte in name field: %d\n"), * name);
17369           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17370           text = tmpbuf;
17371           name ++;
17372         }
17373       expected_types = "*$!+";
17374       break;
17375     }
17376
17377   if (text)
17378     left -= printf ("%s", text);
17379
17380   if (strchr (expected_types, name_type) == NULL)
17381     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17382
17383   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17384     {
17385       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17386              (unsigned long) pnote->namesz,
17387              (long) (name - pnote->namedata));
17388       return FALSE;
17389     }
17390
17391   if (left < 1 && ! do_wide)
17392     return TRUE;
17393
17394   switch (name_type)
17395     {
17396     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17397       {
17398         unsigned int        bytes;
17399         unsigned long long  val = 0;
17400         unsigned int        shift = 0;
17401         char *              decoded = NULL;
17402
17403         bytes = pnote->namesz - (name - pnote->namedata);
17404         if (bytes > 0)
17405           /* The -1 is because the name field is always 0 terminated, and we
17406              want to be able to ensure that the shift in the while loop below
17407              will not overflow.  */
17408           -- bytes;
17409
17410         if (bytes > sizeof (val))
17411           {
17412             fprintf (stderr, "namesz %lx name %p namedata %p\n",
17413                      pnote->namesz, name, pnote->namedata);
17414             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17415                    bytes);
17416             bytes = sizeof (val);
17417           }
17418         /* We do not bother to warn if bytes == 0 as this can
17419            happen with some early versions of the gcc plugin.  */
17420
17421         while (bytes --)
17422           {
17423             unsigned long byte = (* name ++) & 0xff;
17424
17425             val |= byte << shift;
17426             shift += 8;
17427           }
17428
17429         switch (name_attribute)
17430           {
17431           case GNU_BUILD_ATTRIBUTE_PIC:
17432             switch (val)
17433               {
17434               case 0: decoded = "static"; break;
17435               case 1: decoded = "pic"; break;
17436               case 2: decoded = "PIC"; break;
17437               case 3: decoded = "pie"; break;
17438               case 4: decoded = "PIE"; break;
17439               default: break;
17440               }
17441             break;
17442           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17443             switch (val)
17444               {
17445                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17446               case 0: decoded = "off"; break;
17447               case 1: decoded = "on"; break;
17448               case 2: decoded = "all"; break;
17449               case 3: decoded = "strong"; break;
17450               case 4: decoded = "explicit"; break;
17451               default: break;
17452               }
17453             break;
17454           default:
17455             break;
17456           }
17457
17458         if (decoded != NULL)
17459           {
17460             print_symbol (-left, decoded);
17461             left = 0;
17462           }
17463         else if (val == 0)
17464           {
17465             printf ("0x0");
17466             left -= 3;
17467           }
17468         else
17469           {
17470             if (do_wide)
17471               left -= printf ("0x%llx", val);
17472             else
17473               left -= printf ("0x%-.*llx", left, val);
17474           }
17475       }
17476       break;
17477     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17478       left -= print_symbol (- left, name);
17479       break;
17480     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17481       left -= print_symbol (- left, "true");
17482       break;
17483     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17484       left -= print_symbol (- left, "false");
17485       break;
17486     }
17487
17488   if (do_wide && left > 0)
17489     printf ("%-*s", left, " ");
17490
17491   return TRUE;
17492 }
17493
17494 /* Note that by the ELF standard, the name field is already null byte
17495    terminated, and namesz includes the terminating null byte.
17496    I.E. the value of namesz for the name "FSF" is 4.
17497
17498    If the value of namesz is zero, there is no name present.  */
17499
17500 static bfd_boolean
17501 process_note (Elf_Internal_Note *  pnote,
17502               FILE *               file)
17503 {
17504   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17505   const char * nt;
17506
17507   if (pnote->namesz == 0)
17508     /* If there is no note name, then use the default set of
17509        note type strings.  */
17510     nt = get_note_type (pnote->type);
17511
17512   else if (const_strneq (pnote->namedata, "GNU"))
17513     /* GNU-specific object file notes.  */
17514     nt = get_gnu_elf_note_type (pnote->type);
17515
17516   else if (const_strneq (pnote->namedata, "FreeBSD"))
17517     /* FreeBSD-specific core file notes.  */
17518     nt = get_freebsd_elfcore_note_type (pnote->type);
17519
17520   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17521     /* NetBSD-specific core file notes.  */
17522     nt = get_netbsd_elfcore_note_type (pnote->type);
17523
17524   else if (const_strneq (pnote->namedata, "NetBSD"))
17525     /* NetBSD-specific core file notes.  */
17526     return process_netbsd_elf_note (pnote);
17527
17528   else if (strneq (pnote->namedata, "SPU/", 4))
17529     {
17530       /* SPU-specific core file notes.  */
17531       nt = pnote->namedata + 4;
17532       name = "SPU";
17533     }
17534
17535   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17536     /* VMS/ia64-specific file notes.  */
17537     nt = get_ia64_vms_note_type (pnote->type);
17538
17539   else if (const_strneq (pnote->namedata, "stapsdt"))
17540     nt = get_stapsdt_note_type (pnote->type);
17541
17542   else
17543     /* Don't recognize this note name; just use the default set of
17544        note type strings.  */
17545     nt = get_note_type (pnote->type);
17546
17547   printf ("  ");
17548
17549   if (((const_strneq (pnote->namedata, "GA")
17550         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17551        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17552       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17553           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17554     print_gnu_build_attribute_name (pnote);
17555   else
17556     print_symbol (-20, name);
17557
17558   if (do_wide)
17559     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17560   else
17561     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17562
17563   if (const_strneq (pnote->namedata, "IPF/VMS"))
17564     return print_ia64_vms_note (pnote);
17565   else if (const_strneq (pnote->namedata, "GNU"))
17566     return print_gnu_note (pnote);
17567   else if (const_strneq (pnote->namedata, "stapsdt"))
17568     return print_stapsdt_note (pnote);
17569   else if (const_strneq (pnote->namedata, "CORE"))
17570     return print_core_note (pnote);
17571   else if (((const_strneq (pnote->namedata, "GA")
17572              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17573             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17574            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17575                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17576     return print_gnu_build_attribute_description (pnote, file);
17577
17578   if (pnote->descsz)
17579     {
17580       unsigned long i;
17581
17582       printf (_("   description data: "));
17583       for (i = 0; i < pnote->descsz; i++)
17584         printf ("%02x ", pnote->descdata[i]);
17585       if (!do_wide)
17586         printf ("\n");
17587     }
17588
17589   if (do_wide)
17590     printf ("\n");
17591
17592   return TRUE;
17593 }
17594
17595 static bfd_boolean
17596 process_notes_at (FILE *              file,
17597                   Elf_Internal_Shdr * section,
17598                   bfd_vma             offset,
17599                   bfd_vma             length)
17600 {
17601   Elf_External_Note * pnotes;
17602   Elf_External_Note * external;
17603   char * end;
17604   bfd_boolean res = TRUE;
17605
17606   if (length <= 0)
17607     return FALSE;
17608
17609   if (section)
17610     {
17611       pnotes = (Elf_External_Note *) get_section_contents (section, file);
17612       if (pnotes)
17613         {
17614           if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17615             return FALSE;
17616         }
17617     }
17618   else
17619     pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17620                                              _("notes"));
17621   if (pnotes == NULL)
17622     return FALSE;
17623
17624   external = pnotes;
17625
17626   if (section)
17627     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17628   else
17629     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17630             (unsigned long) offset, (unsigned long) length);
17631
17632   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17633
17634   end = (char *) pnotes + length;
17635   while ((char *) external < end)
17636     {
17637       Elf_Internal_Note inote;
17638       size_t min_notesz;
17639       char *next;
17640       char * temp = NULL;
17641       size_t data_remaining = end - (char *) external;
17642
17643       if (!is_ia64_vms ())
17644         {
17645           /* PR binutils/15191
17646              Make sure that there is enough data to read.  */
17647           min_notesz = offsetof (Elf_External_Note, name);
17648           if (data_remaining < min_notesz)
17649             {
17650               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17651                     (int) data_remaining);
17652               break;
17653             }
17654           inote.type     = BYTE_GET (external->type);
17655           inote.namesz   = BYTE_GET (external->namesz);
17656           inote.namedata = external->name;
17657           inote.descsz   = BYTE_GET (external->descsz);
17658           inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17659           /* PR 17531: file: 3443835e.  */
17660           if (inote.descdata < (char *) pnotes || inote.descdata > end)
17661             {
17662               warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17663                     inote.namesz, (long)(end - inote.namedata));
17664               inote.descdata = inote.namedata;
17665               inote.namesz   = 0;
17666             }
17667
17668           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17669           next = inote.descdata + align_power (inote.descsz, 2);
17670         }
17671       else
17672         {
17673           Elf64_External_VMS_Note *vms_external;
17674
17675           /* PR binutils/15191
17676              Make sure that there is enough data to read.  */
17677           min_notesz = offsetof (Elf64_External_VMS_Note, name);
17678           if (data_remaining < min_notesz)
17679             {
17680               warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17681                     (int) data_remaining);
17682               break;
17683             }
17684
17685           vms_external = (Elf64_External_VMS_Note *) external;
17686           inote.type     = BYTE_GET (vms_external->type);
17687           inote.namesz   = BYTE_GET (vms_external->namesz);
17688           inote.namedata = vms_external->name;
17689           inote.descsz   = BYTE_GET (vms_external->descsz);
17690           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17691           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17692           next = inote.descdata + align_power (inote.descsz, 3);
17693         }
17694
17695       if (inote.descdata < (char *) external + min_notesz
17696           || next < (char *) external + min_notesz
17697           /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
17698           || inote.namedata + inote.namesz < inote.namedata
17699           || inote.descdata + inote.descsz < inote.descdata
17700           || data_remaining < (size_t)(next - (char *) external))
17701         {
17702           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17703                 (unsigned long) ((char *) external - (char *) pnotes));
17704           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17705                 inote.type, inote.namesz, inote.descsz);
17706           break;
17707         }
17708
17709       external = (Elf_External_Note *) next;
17710
17711       /* Verify that name is null terminated.  It appears that at least
17712          one version of Linux (RedHat 6.0) generates corefiles that don't
17713          comply with the ELF spec by failing to include the null byte in
17714          namesz.  */
17715       if (inote.namedata[inote.namesz - 1] != '\0')
17716         {
17717           temp = (char *) malloc (inote.namesz + 1);
17718           if (temp == NULL)
17719             {
17720               error (_("Out of memory allocating space for inote name\n"));
17721               res = FALSE;
17722               break;
17723             }
17724
17725           memcpy (temp, inote.namedata, inote.namesz);
17726           temp[inote.namesz] = 0;
17727
17728           /* warn (_("'%s' NOTE name not properly null terminated\n"), temp);  */
17729           inote.namedata = temp;
17730         }
17731
17732       if (! process_note (& inote, file))
17733         res = FALSE;
17734
17735       if (temp != NULL)
17736         {
17737           free (temp);
17738           temp = NULL;
17739         }
17740     }
17741
17742   free (pnotes);
17743
17744   return res;
17745 }
17746
17747 static bfd_boolean
17748 process_corefile_note_segments (FILE * file)
17749 {
17750   Elf_Internal_Phdr * segment;
17751   unsigned int i;
17752   bfd_boolean res = TRUE;
17753
17754   if (! get_program_headers (file))
17755     return TRUE;
17756
17757   for (i = 0, segment = program_headers;
17758        i < elf_header.e_phnum;
17759        i++, segment++)
17760     {
17761       if (segment->p_type == PT_NOTE)
17762         if (! process_notes_at (file, NULL,
17763                                 (bfd_vma) segment->p_offset,
17764                                 (bfd_vma) segment->p_filesz))
17765           res = FALSE;
17766     }
17767
17768   return res;
17769 }
17770
17771 static bfd_boolean
17772 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17773 {
17774   Elf_External_Note * pnotes;
17775   Elf_External_Note * external;
17776   char * end;
17777   bfd_boolean res = TRUE;
17778
17779   if (length <= 0)
17780     return FALSE;
17781
17782   pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17783                                            _("v850 notes"));
17784   if (pnotes == NULL)
17785     return FALSE;
17786
17787   external = pnotes;
17788   end = (char*) pnotes + length;
17789
17790   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17791           (unsigned long) offset, (unsigned long) length);
17792
17793   while ((char *) external + sizeof (Elf_External_Note) < end)
17794     {
17795       Elf_External_Note * next;
17796       Elf_Internal_Note inote;
17797
17798       inote.type     = BYTE_GET (external->type);
17799       inote.namesz   = BYTE_GET (external->namesz);
17800       inote.namedata = external->name;
17801       inote.descsz   = BYTE_GET (external->descsz);
17802       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17803       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17804
17805       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17806         {
17807           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17808           inote.descdata = inote.namedata;
17809           inote.namesz   = 0;
17810         }
17811
17812       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17813
17814       if (   ((char *) next > end)
17815           || ((char *) next <  (char *) pnotes))
17816         {
17817           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17818                 (unsigned long) ((char *) external - (char *) pnotes));
17819           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17820                 inote.type, inote.namesz, inote.descsz);
17821           break;
17822         }
17823
17824       external = next;
17825
17826       /* Prevent out-of-bounds indexing.  */
17827       if (   inote.namedata + inote.namesz > end
17828           || inote.namedata + inote.namesz < inote.namedata)
17829         {
17830           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17831                 (unsigned long) ((char *) external - (char *) pnotes));
17832           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17833                 inote.type, inote.namesz, inote.descsz);
17834           break;
17835         }
17836
17837       printf ("  %s: ", get_v850_elf_note_type (inote.type));
17838
17839       if (! print_v850_note (& inote))
17840         {
17841           res = FALSE;
17842           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17843                   inote.namesz, inote.descsz);
17844         }
17845     }
17846
17847   free (pnotes);
17848
17849   return res;
17850 }
17851
17852 static bfd_boolean
17853 process_note_sections (FILE * file)
17854 {
17855   Elf_Internal_Shdr * section;
17856   unsigned long i;
17857   unsigned int n = 0;
17858   bfd_boolean res = TRUE;
17859
17860   for (i = 0, section = section_headers;
17861        i < elf_header.e_shnum && section != NULL;
17862        i++, section++)
17863     {
17864       if (section->sh_type == SHT_NOTE)
17865         {
17866           if (! process_notes_at (file, section,
17867                                   (bfd_vma) section->sh_offset,
17868                                   (bfd_vma) section->sh_size))
17869             res = FALSE;
17870           n++;
17871         }
17872
17873       if ((   elf_header.e_machine == EM_V800
17874            || elf_header.e_machine == EM_V850
17875            || elf_header.e_machine == EM_CYGNUS_V850)
17876           && section->sh_type == SHT_RENESAS_INFO)
17877         {
17878           if (! process_v850_notes (file,
17879                                     (bfd_vma) section->sh_offset,
17880                                     (bfd_vma) section->sh_size))
17881             res = FALSE;
17882           n++;
17883         }
17884     }
17885
17886   if (n == 0)
17887     /* Try processing NOTE segments instead.  */
17888     return process_corefile_note_segments (file);
17889
17890   return res;
17891 }
17892
17893 static bfd_boolean
17894 process_notes (FILE * file)
17895 {
17896   /* If we have not been asked to display the notes then do nothing.  */
17897   if (! do_notes)
17898     return TRUE;
17899
17900   if (elf_header.e_type != ET_CORE)
17901     return process_note_sections (file);
17902
17903   /* No program headers means no NOTE segment.  */
17904   if (elf_header.e_phnum > 0)
17905     return process_corefile_note_segments (file);
17906
17907   printf (_("No note segments present in the core file.\n"));
17908   return TRUE;
17909 }
17910
17911 static unsigned char *
17912 display_public_gnu_attributes (unsigned char * start,
17913                                const unsigned char * const end)
17914 {
17915   printf (_("  Unknown GNU attribute: %s\n"), start);
17916
17917   start += strnlen ((char *) start, end - start);
17918   display_raw_attribute (start, end);
17919
17920   return (unsigned char *) end;
17921 }
17922
17923 static unsigned char *
17924 display_generic_attribute (unsigned char * start,
17925                            unsigned int tag,
17926                            const unsigned char * const end)
17927 {
17928   if (tag == 0)
17929     return (unsigned char *) end;
17930
17931   return display_tag_value (tag, start, end);
17932 }
17933
17934 static bfd_boolean
17935 process_arch_specific (FILE * file)
17936 {
17937   if (! do_arch)
17938     return TRUE;
17939
17940   switch (elf_header.e_machine)
17941     {
17942     case EM_ARC:
17943     case EM_ARC_COMPACT:
17944     case EM_ARC_COMPACT2:
17945       return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17946                                  display_arc_attribute,
17947                                  display_generic_attribute);
17948     case EM_ARM:
17949       return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17950                                  display_arm_attribute,
17951                                  display_generic_attribute);
17952
17953     case EM_MIPS:
17954     case EM_MIPS_RS3_LE:
17955       return process_mips_specific (file);
17956
17957     case EM_MSP430:
17958      return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17959                                  display_msp430x_attribute,
17960                                  display_generic_attribute);
17961
17962     case EM_NDS32:
17963       return process_nds32_specific (file);
17964
17965     case EM_PPC:
17966     case EM_PPC64:
17967       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17968                                  display_power_gnu_attribute);
17969
17970     case EM_S390:
17971     case EM_S390_OLD:
17972       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17973                                  display_s390_gnu_attribute);
17974
17975     case EM_SPARC:
17976     case EM_SPARC32PLUS:
17977     case EM_SPARCV9:
17978       return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17979                                  display_sparc_gnu_attribute);
17980
17981     case EM_TI_C6000:
17982       return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17983                                  display_tic6x_attribute,
17984                                  display_generic_attribute);
17985
17986     default:
17987       return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17988                                  display_public_gnu_attributes,
17989                                  display_generic_attribute);
17990     }
17991 }
17992
17993 static bfd_boolean
17994 get_file_header (FILE * file)
17995 {
17996   /* Read in the identity array.  */
17997   if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17998     return FALSE;
17999
18000   /* Determine how to read the rest of the header.  */
18001   switch (elf_header.e_ident[EI_DATA])
18002     {
18003     default:
18004     case ELFDATANONE:
18005     case ELFDATA2LSB:
18006       byte_get = byte_get_little_endian;
18007       byte_put = byte_put_little_endian;
18008       break;
18009     case ELFDATA2MSB:
18010       byte_get = byte_get_big_endian;
18011       byte_put = byte_put_big_endian;
18012       break;
18013     }
18014
18015   /* For now we only support 32 bit and 64 bit ELF files.  */
18016   is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
18017
18018   /* Read in the rest of the header.  */
18019   if (is_32bit_elf)
18020     {
18021       Elf32_External_Ehdr ehdr32;
18022
18023       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
18024         return FALSE;
18025
18026       elf_header.e_type      = BYTE_GET (ehdr32.e_type);
18027       elf_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18028       elf_header.e_version   = BYTE_GET (ehdr32.e_version);
18029       elf_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18030       elf_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18031       elf_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18032       elf_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18033       elf_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18034       elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18035       elf_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18036       elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18037       elf_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18038       elf_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18039     }
18040   else
18041     {
18042       Elf64_External_Ehdr ehdr64;
18043
18044       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18045          we will not be able to cope with the 64bit data found in
18046          64 ELF files.  Detect this now and abort before we start
18047          overwriting things.  */
18048       if (sizeof (bfd_vma) < 8)
18049         {
18050           error (_("This instance of readelf has been built without support for a\n\
18051 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18052           return FALSE;
18053         }
18054
18055       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18056         return FALSE;
18057
18058       elf_header.e_type      = BYTE_GET (ehdr64.e_type);
18059       elf_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18060       elf_header.e_version   = BYTE_GET (ehdr64.e_version);
18061       elf_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18062       elf_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18063       elf_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18064       elf_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18065       elf_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18066       elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18067       elf_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18068       elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18069       elf_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18070       elf_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18071     }
18072
18073   if (elf_header.e_shoff)
18074     {
18075       /* There may be some extensions in the first section header.  Don't
18076          bomb if we can't read it.  */
18077       if (is_32bit_elf)
18078         get_32bit_section_headers (file, TRUE);
18079       else
18080         get_64bit_section_headers (file, TRUE);
18081     }
18082
18083   return TRUE;
18084 }
18085
18086 /* Process one ELF object file according to the command line options.
18087    This file may actually be stored in an archive.  The file is
18088    positioned at the start of the ELF object.  Returns TRUE if no
18089    problems were encountered, FALSE otherwise.  */
18090
18091 static bfd_boolean
18092 process_object (char * file_name, FILE * file)
18093 {
18094   unsigned int i;
18095   bfd_boolean res = TRUE;
18096
18097   if (! get_file_header (file))
18098     {
18099       error (_("%s: Failed to read file header\n"), file_name);
18100       return FALSE;
18101     }
18102
18103   /* Initialise per file variables.  */
18104   for (i = ARRAY_SIZE (version_info); i--;)
18105     version_info[i] = 0;
18106
18107   for (i = ARRAY_SIZE (dynamic_info); i--;)
18108     dynamic_info[i] = 0;
18109   dynamic_info_DT_GNU_HASH = 0;
18110
18111   /* Process the file.  */
18112   if (show_name)
18113     printf (_("\nFile: %s\n"), file_name);
18114
18115   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18116      Note we do this even if cmdline_dump_sects is empty because we
18117      must make sure that the dump_sets array is zeroed out before each
18118      object file is processed.  */
18119   if (num_dump_sects > num_cmdline_dump_sects)
18120     memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18121
18122   if (num_cmdline_dump_sects > 0)
18123     {
18124       if (num_dump_sects == 0)
18125         /* A sneaky way of allocating the dump_sects array.  */
18126         request_dump_bynumber (num_cmdline_dump_sects, 0);
18127
18128       assert (num_dump_sects >= num_cmdline_dump_sects);
18129       memcpy (dump_sects, cmdline_dump_sects,
18130               num_cmdline_dump_sects * sizeof (* dump_sects));
18131     }
18132
18133   if (! process_file_header ())
18134     return FALSE;
18135
18136   if (! process_section_headers (file))
18137     {
18138       /* Without loaded section headers we cannot process lots of things.  */
18139       do_unwind = do_version = do_dump = do_arch = FALSE;
18140
18141       if (! do_using_dynamic)
18142         do_syms = do_dyn_syms = do_reloc = FALSE;
18143     }
18144
18145   if (! process_section_groups (file))
18146     /* Without loaded section groups we cannot process unwind.  */
18147     do_unwind = FALSE;
18148
18149   if (process_program_headers (file))
18150     process_dynamic_section (file);
18151   else
18152     res = FALSE;
18153
18154   if (! process_relocs (file))
18155     res = FALSE;
18156
18157   if (! process_unwind (file))
18158     res = FALSE;
18159
18160   if (! process_symbol_table (file))
18161     res = FALSE;
18162
18163   if (! process_syminfo (file))
18164     res = FALSE;
18165
18166   if (! process_version_sections (file))
18167     res = FALSE;
18168
18169   if (! process_section_contents (file))
18170     res = FALSE;
18171
18172   if (! process_notes (file))
18173     res = FALSE;
18174
18175   if (! process_gnu_liblist (file))
18176     res = FALSE;
18177
18178   if (! process_arch_specific (file))
18179     res = FALSE;
18180
18181   if (program_headers)
18182     {
18183       free (program_headers);
18184       program_headers = NULL;
18185     }
18186
18187   if (section_headers)
18188     {
18189       free (section_headers);
18190       section_headers = NULL;
18191     }
18192
18193   if (string_table)
18194     {
18195       free (string_table);
18196       string_table = NULL;
18197       string_table_length = 0;
18198     }
18199
18200   if (dynamic_strings)
18201     {
18202       free (dynamic_strings);
18203       dynamic_strings = NULL;
18204       dynamic_strings_length = 0;
18205     }
18206
18207   if (dynamic_symbols)
18208     {
18209       free (dynamic_symbols);
18210       dynamic_symbols = NULL;
18211       num_dynamic_syms = 0;
18212     }
18213
18214   if (dynamic_syminfo)
18215     {
18216       free (dynamic_syminfo);
18217       dynamic_syminfo = NULL;
18218     }
18219
18220   if (dynamic_section)
18221     {
18222       free (dynamic_section);
18223       dynamic_section = NULL;
18224     }
18225
18226   if (section_headers_groups)
18227     {
18228       free (section_headers_groups);
18229       section_headers_groups = NULL;
18230     }
18231
18232   if (section_groups)
18233     {
18234       struct group_list * g;
18235       struct group_list * next;
18236
18237       for (i = 0; i < group_count; i++)
18238         {
18239           for (g = section_groups [i].root; g != NULL; g = next)
18240             {
18241               next = g->next;
18242               free (g);
18243             }
18244         }
18245
18246       free (section_groups);
18247       section_groups = NULL;
18248     }
18249
18250   free_debug_memory ();
18251
18252   return res;
18253 }
18254
18255 /* Process an ELF archive.
18256    On entry the file is positioned just after the ARMAG string.
18257    Returns TRUE upon success, FALSE otherwise.  */
18258
18259 static bfd_boolean
18260 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18261 {
18262   struct archive_info arch;
18263   struct archive_info nested_arch;
18264   size_t got;
18265   bfd_boolean ret = TRUE;
18266
18267   show_name = TRUE;
18268
18269   /* The ARCH structure is used to hold information about this archive.  */
18270   arch.file_name = NULL;
18271   arch.file = NULL;
18272   arch.index_array = NULL;
18273   arch.sym_table = NULL;
18274   arch.longnames = NULL;
18275
18276   /* The NESTED_ARCH structure is used as a single-item cache of information
18277      about a nested archive (when members of a thin archive reside within
18278      another regular archive file).  */
18279   nested_arch.file_name = NULL;
18280   nested_arch.file = NULL;
18281   nested_arch.index_array = NULL;
18282   nested_arch.sym_table = NULL;
18283   nested_arch.longnames = NULL;
18284
18285   if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18286     {
18287       ret = FALSE;
18288       goto out;
18289     }
18290
18291   if (do_archive_index)
18292     {
18293       if (arch.sym_table == NULL)
18294         error (_("%s: unable to dump the index as none was found\n"), file_name);
18295       else
18296         {
18297           unsigned long i, l;
18298           unsigned long current_pos;
18299
18300           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18301                   file_name, (unsigned long) arch.index_num, arch.sym_size);
18302           current_pos = ftell (file);
18303
18304           for (i = l = 0; i < arch.index_num; i++)
18305             {
18306               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18307                 {
18308                   char * member_name;
18309
18310                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18311
18312                   if (member_name != NULL)
18313                     {
18314                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18315
18316                       if (qualified_name != NULL)
18317                         {
18318                           printf (_("Contents of binary %s at offset "), qualified_name);
18319                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18320                           putchar ('\n');
18321                           free (qualified_name);
18322                         }
18323                     }
18324                 }
18325
18326               if (l >= arch.sym_size)
18327                 {
18328                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18329                          file_name);
18330                   ret = FALSE;
18331                   break;
18332                 }
18333               /* PR 17531: file: 0b6630b2.  */
18334               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18335               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18336             }
18337
18338           if (arch.uses_64bit_indicies)
18339             l = (l + 7) & ~ 7;
18340           else
18341             l += l & 1;
18342
18343           if (l < arch.sym_size)
18344             {
18345               error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18346                      file_name, arch.sym_size - l);
18347               ret = FALSE;
18348             }
18349
18350           if (fseek (file, current_pos, SEEK_SET) != 0)
18351             {
18352               error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18353               ret = FALSE;
18354               goto out;
18355             }
18356         }
18357
18358       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18359           && !do_segments && !do_header && !do_dump && !do_version
18360           && !do_histogram && !do_debugging && !do_arch && !do_notes
18361           && !do_section_groups && !do_dyn_syms)
18362         {
18363           ret = TRUE; /* Archive index only.  */
18364           goto out;
18365         }
18366     }
18367
18368   while (1)
18369     {
18370       char * name;
18371       size_t namelen;
18372       char * qualified_name;
18373
18374       /* Read the next archive header.  */
18375       if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18376         {
18377           error (_("%s: failed to seek to next archive header\n"), file_name);
18378           return FALSE;
18379         }
18380       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18381       if (got != sizeof arch.arhdr)
18382         {
18383           if (got == 0)
18384             break;
18385           error (_("%s: failed to read archive header\n"), file_name);
18386           ret = FALSE;
18387           break;
18388         }
18389       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18390         {
18391           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18392           ret = FALSE;
18393           break;
18394         }
18395
18396       arch.next_arhdr_offset += sizeof arch.arhdr;
18397
18398       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18399       if (archive_file_size & 01)
18400         ++archive_file_size;
18401
18402       name = get_archive_member_name (&arch, &nested_arch);
18403       if (name == NULL)
18404         {
18405           error (_("%s: bad archive file name\n"), file_name);
18406           ret = FALSE;
18407           break;
18408         }
18409       namelen = strlen (name);
18410
18411       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18412       if (qualified_name == NULL)
18413         {
18414           error (_("%s: bad archive file name\n"), file_name);
18415           ret = FALSE;
18416           break;
18417         }
18418
18419       if (is_thin_archive && arch.nested_member_origin == 0)
18420         {
18421           /* This is a proxy for an external member of a thin archive.  */
18422           FILE * member_file;
18423           char * member_file_name = adjust_relative_path (file_name, name, namelen);
18424
18425           if (member_file_name == NULL)
18426             {
18427               ret = FALSE;
18428               break;
18429             }
18430
18431           member_file = fopen (member_file_name, "rb");
18432           if (member_file == NULL)
18433             {
18434               error (_("Input file '%s' is not readable.\n"), member_file_name);
18435               free (member_file_name);
18436               ret = FALSE;
18437               break;
18438             }
18439
18440           archive_file_offset = arch.nested_member_origin;
18441
18442           if (! process_object (qualified_name, member_file))
18443             ret = FALSE;
18444
18445           fclose (member_file);
18446           free (member_file_name);
18447         }
18448       else if (is_thin_archive)
18449         {
18450           /* PR 15140: Allow for corrupt thin archives.  */
18451           if (nested_arch.file == NULL)
18452             {
18453               error (_("%s: contains corrupt thin archive: %s\n"),
18454                      file_name, name);
18455               ret = FALSE;
18456               break;
18457             }
18458
18459           /* This is a proxy for a member of a nested archive.  */
18460           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18461
18462           /* The nested archive file will have been opened and setup by
18463              get_archive_member_name.  */
18464           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18465             {
18466               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18467               ret = FALSE;
18468               break;
18469             }
18470
18471           if (! process_object (qualified_name, nested_arch.file))
18472             ret = FALSE;
18473         }
18474       else
18475         {
18476           archive_file_offset = arch.next_arhdr_offset;
18477           arch.next_arhdr_offset += archive_file_size;
18478
18479           if (! process_object (qualified_name, file))
18480             ret = FALSE;
18481         }
18482
18483       if (dump_sects != NULL)
18484         {
18485           free (dump_sects);
18486           dump_sects = NULL;
18487           num_dump_sects = 0;
18488         }
18489
18490       free (qualified_name);
18491     }
18492
18493  out:
18494   if (nested_arch.file != NULL)
18495     fclose (nested_arch.file);
18496   release_archive (&nested_arch);
18497   release_archive (&arch);
18498
18499   return ret;
18500 }
18501
18502 static bfd_boolean
18503 process_file (char * file_name)
18504 {
18505   FILE * file;
18506   struct stat statbuf;
18507   char armag[SARMAG];
18508   bfd_boolean ret = TRUE;
18509
18510   if (stat (file_name, &statbuf) < 0)
18511     {
18512       if (errno == ENOENT)
18513         error (_("'%s': No such file\n"), file_name);
18514       else
18515         error (_("Could not locate '%s'.  System error message: %s\n"),
18516                file_name, strerror (errno));
18517       return FALSE;
18518     }
18519
18520   if (! S_ISREG (statbuf.st_mode))
18521     {
18522       error (_("'%s' is not an ordinary file\n"), file_name);
18523       return FALSE;
18524     }
18525
18526   file = fopen (file_name, "rb");
18527   if (file == NULL)
18528     {
18529       error (_("Input file '%s' is not readable.\n"), file_name);
18530       return FALSE;
18531     }
18532
18533   if (fread (armag, SARMAG, 1, file) != 1)
18534     {
18535       error (_("%s: Failed to read file's magic number\n"), file_name);
18536       fclose (file);
18537       return FALSE;
18538     }
18539
18540   current_file_size = (bfd_size_type) statbuf.st_size;
18541
18542   if (memcmp (armag, ARMAG, SARMAG) == 0)
18543     {
18544       if (! process_archive (file_name, file, FALSE))
18545         ret = FALSE;
18546     }
18547   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18548     {
18549       if ( ! process_archive (file_name, file, TRUE))
18550         ret = FALSE;
18551     }
18552   else
18553     {
18554       if (do_archive_index)
18555         error (_("File %s is not an archive so its index cannot be displayed.\n"),
18556                file_name);
18557
18558       rewind (file);
18559       archive_file_size = archive_file_offset = 0;
18560
18561       if (! process_object (file_name, file))
18562         ret = FALSE;
18563     }
18564
18565   fclose (file);
18566   current_file_size = 0;
18567
18568   return ret;
18569 }
18570
18571 #ifdef SUPPORT_DISASSEMBLY
18572 /* Needed by the i386 disassembler.  For extra credit, someone could
18573    fix this so that we insert symbolic addresses here, esp for GOT/PLT
18574    symbols.  */
18575
18576 void
18577 print_address (unsigned int addr, FILE * outfile)
18578 {
18579   fprintf (outfile,"0x%8.8x", addr);
18580 }
18581
18582 /* Needed by the i386 disassembler.  */
18583 void
18584 db_task_printsym (unsigned int addr)
18585 {
18586   print_address (addr, stderr);
18587 }
18588 #endif
18589
18590 int
18591 main (int argc, char ** argv)
18592 {
18593   int err;
18594
18595 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18596   setlocale (LC_MESSAGES, "");
18597 #endif
18598 #if defined (HAVE_SETLOCALE)
18599   setlocale (LC_CTYPE, "");
18600 #endif
18601   bindtextdomain (PACKAGE, LOCALEDIR);
18602   textdomain (PACKAGE);
18603
18604   expandargv (&argc, &argv);
18605
18606   parse_args (argc, argv);
18607
18608   if (num_dump_sects > 0)
18609     {
18610       /* Make a copy of the dump_sects array.  */
18611       cmdline_dump_sects = (dump_type *)
18612           malloc (num_dump_sects * sizeof (* dump_sects));
18613       if (cmdline_dump_sects == NULL)
18614         error (_("Out of memory allocating dump request table.\n"));
18615       else
18616         {
18617           memcpy (cmdline_dump_sects, dump_sects,
18618                   num_dump_sects * sizeof (* dump_sects));
18619           num_cmdline_dump_sects = num_dump_sects;
18620         }
18621     }
18622
18623   if (optind < (argc - 1))
18624     show_name = TRUE;
18625   else if (optind >= argc)
18626     {
18627       warn (_("Nothing to do.\n"));
18628       usage (stderr);
18629     }
18630
18631   err = FALSE;
18632   while (optind < argc)
18633     if (! process_file (argv[optind++]))
18634       err = TRUE;
18635
18636   if (dump_sects != NULL)
18637     free (dump_sects);
18638   if (cmdline_dump_sects != NULL)
18639     free (cmdline_dump_sects);
18640
18641   return err ? EXIT_FAILURE : EXIT_SUCCESS;
18642 }